解讀KMP算法

先後斷斷續續搞了5個月，每次都覺得本身懂了， 可是要寫的時候都不知從何下手，而後又是各類找博客，看帖子，因此此次試着用本身的語言寫一個博客。
首先，KMP算法就是從一個模板字符串（S） 中匹配目標字符串（P）。匹配的話，首先就是想到了暴力匹配，也就是用兩個下標表示在S的下標（si） 和 P的下標（pi), 而後進行循環，若是s.chatAt(si)==p.chatAt(pi)就是si ++， pi++； 若是不相等的話，就須要把si = si - pi + 1, pi = 0; ，而後判斷 pi == p.length()
相等的話，就是匹配成功，能夠返回， 不相等就繼續。 下面貼一下代碼， 圖就不畫了。

public int violenceMatch(String s, String p){
     int sLen = s.length(), pLen = p.length();
     int si = 0, pi = 0;
     while (si < sLen && pi < pLen) {
       if (s.charAt(si) == p.charAt(pi)) {
         si++;
         pi++;
       } else {
         si = si - pi + 1;
         pi = 0;
       }
     }
     if (pi == pLen) {
       return si - pi;
     } else {
       return  -1;
     }
   }

使用暴力匹配的缺點很明顯，就是每次失配（就是s.chatAt(si) != p.chatAt(pi）的時候，須要把 si 的位置 置爲s.chatAt(si)==p.chatAt(pi)開始的點的下一位，這樣會出現不少重複無效的匹配。
KMP算法就是把這些重複無效的匹配解決了，具體怎麼解決，這個也是KMP算法的精髓（next數組的求解）。 關於next數組的求解，咱們稍後說，咱們先體會一下 怎麼使用KMP算法來進行字符串匹配（若是隻想了解next數組是怎麼求出來的，能夠跳過這部分）， 舉個例子，有模式串S: "CDABADABCABADABAB", 目標串P: "ABADABAB"用目標串推出的next數組是{0,0,1,0,1,2,3,2}(後面會具體講怎麼推出來的)，如今咱們開始使用KMP算法進行匹配。一開始是 si = 0， pi = 0。

咱們能夠看到這個位置不匹配的，而後由於當前pi == 0 因此直接si += 1 pi 不動 進行下一步 此時 si = 1，pi = 0

此時也是不匹配的， 而後重複上一步， 此時 si = 2, pi = 0

當si = 2， pi= 0的時候，s.chatAt(si) == p.chatAt(pi) ，因此此時 si += 1, pi += 1， 重複這樣匹配，咱們發如今si = 8,pi=6的時候失配了，這是用就須要用到咱們的next數組了。
這裏先簡單說next數組的同樣，是當前下標所對應的最長公共先後綴，注意是最長，不是個數，是長度!!! 公共先後綴，都是基於當前下標來講的。舉個例子 ABA 這個next數組是 {0 0 1} 對於0下標，沒有先後綴， 由於只有1個數， 對於1的下標，前綴是A， 後綴是B，A != B, 因此仍是0， 對於2的下標，前綴有 A， AB，後綴有 BA，A，因此值爲1 ，後面會有詳細的介紹，這裏只要分辨出前綴和後綴就能夠了。
回到正題， 咱們當前位置是失配， 因此須要用到next數組，那麼這個next數組在這裏有什麼用呢？ 咱們試想一下，在當前下標失配， 說明我前面的都是能夠匹配上的，咱們的next數組是保存了最長的公共先後綴，咱們是否是能夠把失配下標的前一個位置在next數組中對應的最大公共先後綴值來做爲目標串（P）移動的距離，由於我當前失配的下標的前一個下標有必定的匹配距離，而後這個下標所對應的前綴是否是能夠省略比對，直接移動最長公共先後綴的距離。 這裏pi = 6的時候失配， next[6 - 1] = 2， 也就是前綴AB （下標0、1）和 後綴AB（下標四、5），咱們是否是能夠省略AB的比較，直接從 ABAD的A開始繼續匹配。由於對於 pi = 6來講， pi = 4, pi=5都是和S串上能夠匹配上，省略pi = 0， pi = 1的比較，直接從pi = 2開始和si= 8 繼續比對，因此下標變化是si = 8, pi = next[6 - 1]=2也就是下圖：

此時對於si = 8, pi= 2 仍然沒有匹配上，而後再次使用next數組， next[2 - 1] = 0，因此有 si = 8, pi = next[2 - 1] = 0

此時仍是沒有匹配上，可是pi = 0， 因此 si+=1，此時 si = 9, pi = 0

後面下去都是匹配上了。因此能夠返回下標。
可能看到這裏，你仍是疑惑這個next下標爲何要這樣用呢？這裏總結一下，而後就解釋next數組的推導過程。 咱們在 失配的時候，就須要移動目標串，問題是移動多少呢？不一樣於暴力匹配的作法，將 si和pi都一塊兒移動，而是隻移動 pi，這個移動的距離，和next數組有關，咱們當前失配的位置的前一個位置是能夠和S模式串失配前的位置是能夠匹配的，因此咱們只要移動當前pi的前一個位置的最大公共先後綴距離，而後本來由後綴匹配的字符給前綴匹配（由於知道了最大公共先後綴的距離，因此這部分只是移動而已，不須要再從新的匹配），而後在失配的地方繼續進行新的比對。
這裏開始講解一下next的推導。咱們在前面提到過，next數組對於當前下標所對應的最長公共先後綴，因此咱們從index = 1 開始，由於 0 下標只有1個字符，沒有先後綴

對於下標1，咱們能夠很清楚的看到， 前綴是A， 後綴是B，A != B, 因此next[index] = 0，對下標index = 2進行查看

對於下標2，咱們也能夠很清楚的看到，前綴是A、AB，後綴是BA,A，只有A == A，因此next[index] = 1,好像到這裏仍是很簡單，咱們能夠先推出一個公式，p.chatAt(index) == p.chatAt(next[index - 1]) 成立的話 next[index] = next[index - 1] + 1, 不成立的話 next[index] = 0,後面咱們就用這個公式進行求解，看下這個公式是否成立，在驗證結果以前，我先說一下爲何會得出這樣的公式， next數組是保存了最長公共先後綴，這個概念說過不少次了，由於它特別重要。 咱們對於當前下標，要想找到最長的公共先後綴，最好的辦法就是在前一個下標的最長公共先後綴的基礎上+1，這點沒有問題吧，因此就有了 p.chatAt(index) == p.chatAt(next[index - 1])。 那麼接下來，咱們就來驗證一下這個公式的正確性了。對於下標 index = 3，

有p.chatAt(3) != p.chatAt(next[3 - 1])因此next[3] = 0，咱們也能夠看出next[3]確實是0， 繼續 index = 4

在index = 4的時候，有 p.chatAt(4) == p.chatAt(next[4 - 1]) 因此next[4] = next[4 - 1] + 1，確實沒錯，繼續index = 5

在next = 5的時候，有p.chatAt(5) == p.chatAt(next[5 - 1]) 因此next[5] = next[5 - 1] + 1,也沒有錯誤 ，繼續 index = 6

在next =6 的時候， 有p.chatAt(6) == p.chatAt(next[6 - 1]), 因此next[6] = next[6 - 1] + 1, 也沒有錯誤，繼續 index = 7

在next = 7 的時候， 有p.chatAt(7) != p.chatAt(next[7 - 1]), 按照公式，此時的next[7] 應該是0 纔對呀，可是我寫的是 2，咱們能夠看一下，確實也是2 由於前綴 AB 和後綴AB相等，因此是2， 可是這是爲何呢？咱們能夠知道 p.chatAt(7) 確實是不等於 p.chatAt(next[7 - 1])，可是不要忘記，咱們的next保存的是最長公共先後綴，next[7 - 1] = 3，說明下標0 、 一、 2和下標四、五、6是一一對應的，因此咱們對下標4 和7進行比較，發現不相等，按照一開始的思路，咱們會把next[7]設爲0， 可是咱們能夠看一下下標 0、 一、 2 、 3這裏，對於下標3 是咱們下標7要比較的，可是看一下下標2的位置在next數組是1，這代表了，對於下標2，的最長公共先後綴是1，在求next[3]的時候，咱們用p.chatAt(3) 和p.chatAt(next[3 - 1])進行比較，對於如今的下標7， 咱們是否是能夠把它當成是下標3 呢？ 徹底能夠，由於下標0、一、2和下標四、五、6一一對應， 下標3 和7 沒有匹配上，就能夠把下標7 當作是下標3， 此時應該是用 p.chatAt(7) 和 p.chatAt(next[3 - 1]), 對於爲何前面是7 後面是next[3- 1] 而不是next[7 - 1]的，若是用next[7 - 1]了， 是否是就陷入了死循環了？ 其實這裏也就是把3的下標看成是7來看待，對於3前面的沒有其餘影響，因此纔是這樣的。 那麼到了此時，咱們能夠很清晰的求出next數組，而後結合前面的講解， 就是一個完整的KMP了。
第一次寫博客寫了2000+字，花費了一些心血畫圖，試圖用最簡單的話來敘述這個算法，可是好像沒有作到，有一些東西在我這個層次尚未看到，因此也沒有用到最簡單的話來敘述徹底部，你們能多看幾遍，也是能夠理解這個算法的精妙之處。最後貼一下完整代碼：

package com.hl.solution;


/**
 * @author Hl
 * @create 2021/3/3 0:18
 */
public class KMP {

    public static void main(String[] args) {
        KMP kmp = new KMP();
        String s = "BBC ABCDAB ABCDABCDABDE";
        String p = "12";
        int i = kmp.kmpMatch(s, p);
        int j = kmp.violenceMatch(s, p);
        System.out.println("KMP算法結果： "+i);
        System.out.println("暴力匹配結果： " + j);

    }
	
  // KMP匹配
    public int kmpMatch(String s, String p){
        int[] next = getNext(p);
        int sLen = s.length(), pLen = p.length();
        int sl = 0, pl = 0;
        while (sl < sLen) {
            if (s.charAt(sl) == p.charAt(pl)) {
                sl++;
                pl++;
            } else if (pl == 0) sl++;
            else pl = next[pl - 1];
            if (pl == pLen) {
                return sl - pl;
            }
        }
        return -1;
    }

  // 求next數組
    public int[] getNext(String p){
        int[] next = new int[p.length()];
        for (int i = 1; i < p.length(); i++) {
            int index = next[i - 1];
            while (index > 0 && p.charAt(i) != p.charAt(index)) {
                index = next[index - 1];
            }
            if (p.charAt(i) == p.charAt(index)) {
                next[i] = index + 1;
            }
        }
        return next;
    }

  // 暴力匹配
    public int violenceMatch(String s, String p){
        int sLen = s.length(), pLen = p.length();
        int si = 0, pi = 0;
        while (si < sLen && pi < pLen) {
            if (s.charAt(si) == p.charAt(pi)) {
                si++;
                pi++;
            } else {
                si = si - pi + 1;
                pi = 0;
            }
        }
        if (pi == pLen) {
            return si - pi;
        } else {
            return  -1;
        }
    }
}

但願你們都能在我這裏獲得一些收穫，感謝看了這麼久........