KMP 演算法真的很簡單

KMP 是字串匹配的經典演算法，曾經一度對其敬而遠之，感覺很難寫出來正確的 KMP 演算法，這都是拜那些“教科書”所賜，在它們的教授下，不禁感覺 KMP 很難！

其實理解 KMP 演算法很簡單，今天就來看個究竟，我的目標就是從幾個簡單的數學等式推匯出 KMP 演算法，簡單但嚴謹。

串匹配

先來回憶一下串匹配場景，不外乎是給定兩個字串 S 和 T ，然後在 S 串中查詢 T 串，如果查詢成功就是匹配，否則就是不匹配。比如：

S = “avantar-titanic”; T = “avantar”; C = “tistan” ；那麼結果就是 T 匹配 S ，而 C

樸素的串匹配演算法

再來回顧一下樸素的匹配思想，從 S[i] 開始，逐個檢查 S[i+pos] 是否與 T[pos] 相等，如果 S[i+pos] = T[pos] ，那麼 pos++ ；如果 S[i+pos] != T[pos] ，那麼 T 就要回退到 T[0] ，然後再從 S[i+1] 開始嘗試匹配 T ，這就是下面的虛擬碼。

for(int i = 0; i < Len[S]; i++) { int j; for(j = 0; j < Len[T]); j++) { if(S[i+j] != T[j]) break; } if(j == Len[T]) find T in S }

上面演算法的問題就在於，如果出現了不匹配的情況， T 就要回退到 T[0] ，演算法複雜度為 O(len[S]*len[T]) 。

需要從頭再來嗎？

讓我們來重新審視上面的問題，在 S 串中查詢 T 串，我們使用表示法 C [i, j] 表示 C 的字串 S _i S _i+1 …S _j 。 假設當前時刻 S 從位置 i 開始，已經匹配了 pos 個長度，也就是 S[i, i+pos-1] = T[0, pos-1] ，繼續向下進行比較；

如果 S[i+pos] = T[pos] ，那麼依然有 S[i, i+pos] = T[0, pos] ；

如果 S[i+pos] != T[pos] ，那麼將有

這時候 樸素的串匹配思想就是回退 T 到 T[0] ， 從 S[i+1] 和 T[0] 開始再次逐 字元的比較。然而仔細觀察這個時刻，假設我們不讓 T 回退到 T[0] ，而是回退到 T[j] 的位置，並讓 S 停留在 S[i+pos-1] 的位置，並且滿足

S[i+pos-j-1, i+pos-1] = T[0, j] -------------------------(1)

那麼必然 j<pos-1 ，然後再從 S[i+pos] 和 T[j+1] 開始 逐 字元的比較，這樣不就更加高效了嗎？下面就來看看能不能找到這個 j 。

採用假設法，假設 j 已經找到了，那麼等式 (1) 成立。

當匹配進行到 S[i+pos] != T[pos] 時，我們已經有 S[i, i+pos-1] = T[0, pos-1] ，取後面的 j 個字串就有：

S[i+pos-j, i+pos-1] = T[pos-j, pos-1] ------------------(2)

根據等式 (1) 和等式 (2) ，我們便可得到

T[pos-j, pos-1] = T[0, j] ----------------------------------(3)

也就是說，如果找到了這樣的 j ，那麼必然滿足等式 (3) 。於是我們可以採用一個數組 P ，記住每個 pos 對應的 j ；也就是 P[pos] = j ，當 T[pos] 不能匹配時，就讓 T 回退到 j ，繼續和 S[i+pos] 匹配； pos 的範圍是 0~len[T] 。

如果 j = 0 ，意味著 S[i+pos-1] = T[0] = T[pos-1] ；

如果這個 j 不存在呢，這是很可能發生的，世界不是總是這麼美好的嘛，這個時候意味著 S[i+pos-1] != T[0] ，那麼我們只能從 S[i+pos] 和 T[0] 開始匹配了。

如果對應於每個 pos 我們都找到對應的 j ，那麼不就可以改進上面樸素的匹配演算法了嗎？姑且把這個結果儲存在陣列 next 中，於是 next 的定義就是：

next[pos] 表明如果在 pos 處 T[pos] 和 S[m] 不能匹配，但是 T[0, next[pos]] = S[m-next[pos]-1, m-1] 成立，於是應該回退到 T[next[pos]+1] 處和 S[m] 進行匹配。

這時候匹配演算法的邏輯就像下面那樣：

If S[i] = T[j] then // 如果匹配就繼續向後

i++

j++

if j = Len[T] then

find a match position

endif

else

loop // 找到使 S[i] = T[j’] 的 j’

j = next[j]

until S[i] = T[j] or j < 0

if j < 0 then // j < 0 表明 S[i] != T[0] ，從 i+1 位置匹配 T[0]

j = -1

endif

i++

endif

改進後的匹配演算法

根據上面的思想，那麼我們可以很容易的寫出匹配演算法的程式碼。

  // search T in S int tlen = strlen(T); int slen = strlen(S); for(int i = 0, j = 0; i < slen;) { if(S[i] == T[j]) // 如果S[i]和S[j]匹配，則繼續比較S[i+1],T[j+1] { i++; j++; if(j == tlen) // 找到了一個匹配 { printf("find [%s] in [%s] at pos %d./n", T, S, i-tlen); j = 0; // 尋找下一個匹配 } } else // 如果不匹配，則根據P陣列尋找j' { // 直到找到一個j'使得S[i] = T[j']，或者j'=-1 while((j >= 0) && (S[i] != T[j])) { j = next[j]; } if(j == -1) // j'=-1，表明S[i] != T[0]，只能嘗試從S[i+1]開始匹配T { j = 0; } i++; } } 

計算next陣列

現在另外一個問題出現了，如何求next陣列呢？根據前面的分析可以知道next陣列只和T串有關，再說一下next的定義：

next[pos]表明如果在pos處T[pos]和S[m]不能匹配，但是T[0, next[pos]] = S[m-next[pos]-1, m-1]成立，於是應該回退到T[next[pos]+1]處和S[m]進行匹配。

最簡單的情況開始，next[0]=-1，因為如果T[0] != S[m]那麼只能嘗試T[0] ? S[m+1];

不難理解，如果T[0] = T[1]，那麼next[1] = 0，否則next[1] = -1；

對於next[pos] = j 滿足T[pos-j, pos-1] = T[0, j]，因此可以通過蠻力方法找到這個next陣列，只是效率太低，還有更好的方法嗎？

如果當前已知next[0],...,next[pos-1]，能否通過它們的值來計算next[pos]呢，假設next[pos-1] = j；

1 如果T[j+1] = T[pos]，那麼結合T[pos-j-1, pos-1] = T[0, j]可知

T[pos-j-1, pos] = T[0, j+1]

於是next[pos] = j+1；

2 如果T[j+1] != T[pos]，那麼T[pos-j-1, pos] != T[0, j+1]，這時候如何求next[pos]呢？假設next[pos] = j’，如果j’ > -1，那麼有T[pos-j’, pos] = T[0, j’]。

再考慮對於任意i < pos-1, next[i] = p’， T[i-p’, i] = T[0, p’]，那麼p’肯定<j

現在已經有T[pos-j-1, pos-1] = T[0, j]，於是T[pos-p’-1, pos-1] = T[0, p’]；

如果T[pos] = T[p’+1]的話，就意味著T[pos-p’-1, pos] = T[0,p’+1]

於是next[pos] = next[i] +1；

看來我們找到了求next陣列的方法，看看是不是和匹配演算法很相似呢，虛擬碼如下所示：

next[0] = -1

i = 1

j = -1 // j 從 next[0]開始

// 迴圈直到i=Len[T]

If T[i] = T[j+1] then // 如果匹配就繼續向後

next[i] = j+1 // 計算next[i]

i++

j++

else

loop // 找到使T[i] = T[j’+1]的j’

j = next[j]

until T[i] = T[j] or j < 0

if j < 0 then // j < 0表明T[i] = -1

next[i] = j = -1

endif

i++

endif

c++程式碼如下:

// 把尋找next陣列的過程，看做是T和自身匹配的過程 void _Next(const char *T, int *next, int tlen) { const char *S = T; next[0] = -1; for(int i = 1, j = -1; i < tlen;) { if(S[i] == T[j+1]) { next[i] = j+1; // 匹配成功則更新next[i] i++; j++; } else { while((j >= 0) && (S[i] != T[j+1])) { j = next[j]; } if(j == -1) { next[i] = -1; } i++; } } }

KMP匹配演算法

KMP相對於樸素的匹配思想就是當不匹配時，T不必回退到T[0]，從而提高了匹配效率。

上面的程式碼似曾相似啊，其實它就是KMP匹配演算法，簡單調整一下程式碼邏輯就和常見的KMP演算法相似了。

KMP演算法其實不難，幾個簡單的數學等式就能推出來了嘛，其餘的複雜性證明就略過了。