目的：

為了解決字串模式匹配

歷程：

樸素模式匹配：逐次進行比較

KMP演算法：利用匹配失敗得到的資訊，來最大限度的移動模式串，以此來減少比較次數提高效能

概念：

m：是目標串長度

n：是模式串長度

j：某次匹配時，第一次出現的不同的索引位置（有的稱為：失配位）

k：最長首尾串長度（有的稱為：最長公共前後綴）

核心思想：

S   S₀ S₁ ...... S_i-j-1 S_i-j S_i-j+1 S_i-j+2 ...... S_i-2 S_i-1 S_i ...... S_n-1

                              ||     ||      ||            ||   ||   ×

P                            P₀    P₁      P₂              P_j-2 P_j-1 P_j

有S_i-j-1S_i-jS_i-j+1 S_i-j+2 ...... S_i-2 S_{i-1=P0P1 P2 ...... Pj-2 Pj-1}

如果  P₀P₁ P_{2 ......} P_{j-2 ≠ P1 P2 ...... Pj-2Pj-1}

則可以立即斷定 P₀P₁ P_{2 ......} P_{j-2 ≠ Si-j+1 Si-j+2 ...... Si-2 Si-1，即：樸素模式匹配的下一次移動一定不匹配，則可以跳過這一次}

如果  P₀P₁ P_{2 ......} P_{j-3 ≠ P2 ......} 

則可以立即斷定 P₀P₁ P_{2 ......} P_{j-2 ≠ Si-j+1 Si-j+2 ...... Si-2 Si-1，即：樸素模式匹配的下一次移動一定不匹配，則可以跳過這一次}

直到第一次出現相等的情況終止：P₀P₁ P_{2 ......} P_k-1 = P_{j-k ...... Pj-2Pj-1}

得到的k就是最長的首尾串長度，然後通過 j-k 得到了我們需要移動的位數，這樣我們就利用了匹配失敗的結果，得到了我們可以移動的步數，提升了效能

關於k：

其實肉眼就直接能看出來，k是最長首尾串長度，比如：

11111 k=4（字首：1111，字尾：1111）

12112 k=2（字首：12，字尾：12）

12345 k=0（無相同字首字尾）

例子：

S=ababababababb

P=abababb

重申一下原理：樸素模式匹配效率低的原因是一位一位的比較，丟棄了之前失敗的資訊。而KMP演算法從匹配失敗的資訊中得到可以最大移動的步數，以此來減少比較的次數，來提升效能。

這裡並沒有提及，next陣列及newnext陣列，模式串的特徵向量N，其實不用管它，思想理解了，只是別人起了個叫法而已。

Java程式碼：

    /**
     * 樸素模式匹配
     * 
     * @param source 目標串
     * @param pattern 模式串
     */
    private static void plain(String source, String pattern) {
        int res=0;
        int sourceLength=source.length();
        int patternLength=pattern.length();
        for(int i=0;i<=(sourceLength-patternLength);i++){
            res++;
            String str=source.substring(i, i+patternLength);
            if(str.equals(pattern)){
                p("樸素模式：匹配成功");
                break;
            }
        }
        p("樸素模式：一共匹配"+res+"次數");
    }

    //KMP演算法實現
　　 private static void KMP(String source, String pattern) {
        int[] N=getN(pattern);
        int res=0;
        int sourceLength=source.length();
        int patternLength=pattern.length();
        for(int i=0;i<=(sourceLength-patternLength);){
            res++;
            String str=source.substring(i, i+patternLength);//要比較的字串
            p(str);
            int count=getNext(pattern, str,N);
            p("移動"+count+"步");
            if(count==0){
                p("KMP：匹配成功");
                break;
            }
            i=i+count;
        }
        p("KMP：一共匹配"+res+"次數");
    }
    /**
     * 得到下一次要移動的次數
     * 
     * @param pattern
     * @param str
     * @param N
     * @return 0,字串匹配；
     */
    private static int getNext(String pattern,String str,int[] N) {
        int n = pattern.length();
        char v1[] = str.toCharArray();
        char v2[] = pattern.toCharArray();
        int x = 0;
        while (n-- != 0) {
            if (v1[x] != v2[x]){
                if(x==0){
                    return 1;//如果第一個不相同，移動1步
                }
                return x-N[x-1];//x:第一次出現不同的索引的位置，即j
            }
            x++;
        }
        return 0;
    }
    private static int[] getN(String pattern) {
        char[] pat=pattern.toCharArray();
        int j=pattern.length()-1;
        int[] N=new int[j+1];
        for(int i=j;i>=2;i--){
            N[i-1]=getK(i,pat);
        }
        for(int a:N)
            p(a);
        return N;
    }
    private static int getK(int j, char[] pat) {
        int x=j-2;
        int y=1;
        while (x>=0 && compare(pat, 0, x, y, j-1)) {
            x--;
            y++;
        }
        return x+1;
    }
    private static boolean compare(char[] pat,int b1,int e1,int b2,int e2){
        int n = e1-b1+1;
        while (n-- != 0) {
            if (pat[b1] != pat[b2]){
                return true;
            }
            b1++;
            b2++;
        }
        return false;
    }
    public static void p(Object obj) {
        System.out.println(obj);
    }

next陣列：

KMP能提高效能原因是減少了比較次數，也就是知道k

而k從只和j有關，這就意味著移動的次數只和模式串有關，和目標串無關

簡單來說，就是我們得到模式串後就能立馬知道移動的次數，這就是next陣列。裡面儲存的就是k值。