KMP字符串模式匹配算法Java實現

轉載自：http://www.jianshu.com/p/e2bd1ee482c3

本文靈感來自於July的博客從頭到尾徹底理解KMP，並着重於Java實現 :)。現有字符串匹配算法有不少，如簡單暴力的樸素算法(暴力匹配算法)、KMP算法、BM算法以及Sunday算法等，在這裏僅介紹前兩種算法。

1. 樸素算法
樸素算法即暴力匹配算法，對於長度爲n的文本串S和長度爲m模式串P，在文本串S中是否存在一個有效偏移i，其中 0≤ i < n - m + 1，使得 S[i... i+m - 1] = P[0 ... m-1]（注：下標從0開始），如果存在則匹配成功，否則匹配失敗。由於在匹配過程中一旦不匹配，就要讓模式串P相對於文本串S右移1，即i需要進行回溯，其時間複雜度爲O(n*m)。
Java實現：

    // 定義接口
    interface StringMatcher {
        /**
         * 從原字符串中查找模式字符串的位置,如果模式字符串存在,則返回模式字符串第一次出現的位置,否則返回-1
         * 
         * @param source
         *            原字符串
         * @param pattern
         *            模式字符串
         * @return if substring exists, return the first occurrence of pattern
         *         substring, return -1 if not.
         */
        int indexOf(String source, String pattern);
    }
    /**
     * 暴力匹配
     * <p>
     * 時間複雜度: O(m*n), m = pattern.length, n = source.length
     */
    class ViolentStringMatcher implements StringMatcher {

        @Override
        public int indexOf(String source, String pattern) {
            int i = 0, j = 0;
            int sLen = source.length(), pLen = pattern.length();
            char[] src = source.toCharArray();
            char[] ptn = pattern.toCharArray();
            while (i < sLen && j < pLen) {
                if (src[i] == ptn[j]) {
                    // 如果當前字符匹配成功,則將兩者各自增1,繼續比較後面的字符
                    i++;
                    j++;
                } else {
                    // 如果當前字符匹配不成功,則i回溯到此次匹配最開始的位置+1處,也就是i = i - j + 1
                    // (因爲i,j是同步增長的), j = 0;
                    i = i - j + 1;
                    j = 0;
                }
            }
            // 匹配成功,則返回模式字符串在原字符串中首次出現的位置;否則返回-1
            if (j == pLen)
                return i - j;
            else
                return -1;
        }
    }

2. KMP算法
與樸素算法不同，樸素算法是當遇到不匹配字符時，向後移動一位繼續匹配，而KMP算法是當遇到不匹配字符時，不是簡單的向後移一位字符，而是根據前面已匹配的字符數和模式串前綴和後綴的最大相同字符串長度數組next的元素來確定向後移動的位數，所以KMP算法的時間複雜度比樸素算法的要少，並且是線性時間複雜度，即預處理時間複雜度是O(m)，匹配時間複雜度是O(n)。

next數組含義：代表在模式串P中，當前下標對應的字符之前的字符串中，有多大長度的相同前綴後綴。例如如果next [j] = k，代表在模式串P中，下標爲j的字符之前的字符串中有最大長度爲k 的相同前綴後綴。

KMP算法的核心就是求next數組，在字符串匹配的過程中，一旦某個字符匹配不成功，next數組就會指導模式串P到底該相對於S右移多少位再進行下一次匹配，從而避免無效的匹配。

next數組求解方法：

next[0] = -1。
如果已知next[j] = k,如何求出next[j+1]呢?具體算法如下:
1. 如果p[j] = p[k], 則next[j+1] = next[k] + 1;
2. 如果p[j] != p[k], 則令k=next[k],如果此時p[j]==p[k],則next[j+1]=k+1,如果不相等,則繼續遞歸前綴索引,令 k=next[k],繼續判斷,直至k=-1(即k=next[0])或者p[j]=p[k]爲止

詳細的介紹及分析還請移步從頭到尾徹底理解KMP，在下語拙 :(
Java實現：

    /**
     * KMP模式匹配
     * @author Tianma
     *
     */
    class KMPStringMatcher implements StringMatcher {

        /**
         * 獲取KMP算法中pattern字符串對應的next數組
         * 
         * @param p
         *            模式字符串對應的字符數組
         * @return
         */
        protected int[] getNext(char[] p) {
            // 已知next[j] = k,利用遞歸的思想求出next[j+1]的值
            // 如果已知next[j] = k,如何求出next[j+1]呢?具體算法如下:
            // 1. 如果p[j] = p[k], 則next[j+1] = next[k] + 1;
            // 2. 如果p[j] != p[k], 則令k=next[k],如果此時p[j]==p[k],則next[j+1]=k+1,
            // 如果不相等,則繼續遞歸前綴索引,令 k=next[k],繼續判斷,直至k=-1(即k=next[0])或者p[j]=p[k]爲止
            int pLen = p.length;
            int[] next = new int[pLen];
            int k = -1;
            int j = 0;
            next[0] = -1; // next數組中next[0]爲-1
            while (j < pLen - 1) {
                if (k == -1 || p[j] == p[k]) {
                    k++;
                    j++;
                    next[j] = k;
                } else {
                    k = next[k];
                }
            }
            return next;
        }

        @Override
        public int indexOf(String source, String pattern) {
            int i = 0, j = 0;
            char[] src = source.toCharArray();
            char[] ptn = pattern.toCharArray();
            int sLen = src.length;
            int pLen = ptn.length;
            int[] next = getNext(ptn);
            while (i < sLen && j < pLen) {
                // 如果j = -1,或者當前字符匹配成功(src[i] = ptn[j]),都讓i++,j++
                if (j == -1 || src[i] == ptn[j]) {
                    i++;
                    j++;
                } else {
                    // 如果j!=-1且當前字符匹配失敗,則令i不變,j=next[j],即讓pattern模式串右移j-next[j]個單位
                    j = next[j];
                }
            }
            if (j == pLen)
                return i - j;
            return -1;
        }
    }

3. 優化的KMP算法（改進next數組）
具體過程移步從頭到尾徹底理解KMP的3.3.8 Next 數組的優化
在這裏給出Java實現：

    /**
     * 優化的KMP算法(對next數組的獲取進行優化)
     * 
     * @author Tianma
     *
     */
    class OptimizedKMPStringMatcher extends KMPStringMatcher {

        @Override
        protected int[] getNext(char[] p) {
            // 已知next[j] = k,利用遞歸的思想求出next[j+1]的值
            // 如果已知next[j] = k,如何求出next[j+1]呢?具體算法如下:
            // 1. 如果p[j] = p[k], 則next[j+1] = next[k] + 1;
            // 2. 如果p[j] != p[k], 則令k=next[k],如果此時p[j]==p[k],則next[j+1]=k+1,
            // 如果不相等,則繼續遞歸前綴索引,令 k=next[k],繼續判斷,直至k=-1(即k=next[0])或者p[j]=p[k]爲止
            int pLen = p.length;
            int[] next = new int[pLen];
            int k = -1;
            int j = 0;
            next[0] = -1; // next數組中next[0]爲-1
            while (j < pLen - 1) {
                if (k == -1 || p[j] == p[k]) {
                    k++;
                    j++;
                    // 修改next數組求法
                    if (p[j] != p[k]) {
                        next[j] = k;// KMPStringMatcher中只有這一行
                    } else {
                        // 不能出現p[j] = p[next[j]],所以如果出現這種情況則繼續遞歸,如 k = next[k],
                        // k = next[[next[k]]
                        next[j] = next[k];
                    }
                } else {
                    k = next[k];
                }
            }
            return next;
        }

    }

4. 花絮
提到字符串匹配，或者說字符串查找，我們會想到Java中的String類就有一個String.indexOf(String str);方法，那它使用的是什麼算法呢？在這裏截取JavaSE-1.8的源碼：

    // String.indexOf(String str); 最終會調用該方法
    /**
     * Code shared by String and StringBuffer to do searches. The
     * source is the character array being searched, and the target
     * is the string being searched for.
     *
     * @param   source       the characters being searched.(源字符數組)
     * @param   sourceOffset offset of the source string.(源字符數組偏移量)
     * @param   sourceCount  count of the source string.(源字符數組長度)
     * @param   target       the characters being searched for.(待搜索的模式字符數組)
     * @param   targetOffset offset of the target string.(模式字符數組偏移量)
     * @param   targetCount  count of the target string.(模式數組長度)
     * @param   fromIndex    the index to begin searching from.(從原字符數組的哪個下標開始查詢)
     */
    static int indexOf(char[] source, int sourceOffset, int sourceCount,
            char[] target, int targetOffset, int targetCount,
            int fromIndex) {
        if (fromIndex >= sourceCount) {
            return (targetCount == 0 ? sourceCount : -1);
        }
        if (fromIndex < 0) {
            fromIndex = 0;
        }
        if (targetCount == 0) {
            return fromIndex;
        }

        char first = target[targetOffset];
        int max = sourceOffset + (sourceCount - targetCount);

        for (int i = sourceOffset + fromIndex; i <= max; i++) {
            /* Look for first character. */
            // 找到第一個匹配的字符的位置
            if (source[i] != first) {
                while (++i <= max && source[i] != first);
            }

            /* Found first character, now look at the rest of v2 *
            if (i <= max) {
                // 找到了第一個匹配的字符，看餘下的是否完全匹配
                int j = i + 1;
                int end = j + targetCount - 1;
                for (int k = targetOffset + 1; j < end && source[j]
                        == target[k]; j++, k++);

                if (j == end) {
                    /* Found whole string. */
                    return i - sourceOffset;
                }
                // 如果不完全匹配，因爲外層for循環中有i++，即i+1繼續匹配
                // 故而該方法本質上就是字符串匹配的樸素算法
            }
        }
        return -1;
    }

通過對代碼片段的註釋和分析可以看出，Java源碼中的String.indexOf(String str); 內部所使用的算法其實就是字符串匹配的樸素算法...

源碼github地址:
StringMatchSample

重要參考:
從頭到尾徹底理解KMP

KMP字符串模式匹配算法Java實現

含有負數的取模運算

libjvm.so:cannot restore segment prot after reloc:Permission denied

Spark Streaming Backpressure分析

KMP字符串模式匹配算法Java實現

oozie server系統時鐘偏差導致sqoop報錯

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結