數據結構20：KMP算法(快速模式匹配算法)詳解

經過上一節的介紹，學習了串的普通模式匹配算法，大致思路是：模式串從主串的第一個字符開始匹配，每匹配失敗，主串中記錄匹配進度的指針 i 都要進行 i-j+1 的回退操做（這個過程稱爲「指針回溯」），同時模式串向後移動一個字符的位置。一次次的循環，直到匹配成功或者程序結束。

"KMP"算法相比於"BF"算法，優點在於：

• 在保證指針 i 不回溯的前提下，當匹配失敗時，讓模式串向右移動最大的距離；
• 而且能夠在O(n+m)的時間數量級上完成對串的模式匹配操做；

故，"KMP"算法稱爲「快速模式匹配算法」。

模式串向右移動距離的計算

在模式串和主串匹配時，各有一個指針指向當前進行匹配的字符（主串中是指針 i ，模式串中是指針 j ），在保證 i 指針不回溯的前提下，若是想實現功能，就只能讓 j 指針回溯。

j 指針回溯的距離，就至關於模式串向右移動的距離。 j 指針回溯的越多，說明模式串向右移動的距離越長。

計算模式串向右移動的距離，就能夠轉化成：當某字符匹配失敗後， j 指針回溯的位置。

對於一個給定的模式串，其中每一個字符都有可能會遇到匹配失敗，這時對應的 j 指針都須要回溯，具體回溯的位置其實仍是由模式串自己來決定的，和主串沒有關係。

模式串中的每一個字符所對應 j 指針回溯的位置，能夠經過算法得出，獲得的結果相應地存儲在一個數組中（默認數組名爲 next ）。

計算方法是：對於模式串中的某一字符來講，提取它前面的字符串，分別從字符串的兩端查看連續相同的字符串的個數，在其基礎上 +1 ，結果就是該字符對應的值。

每一個模式串的第一個字符對應的值爲 0 ，第二個字符對應的值爲 1 。

例如：求模式串 「abcabac」 的 next 。前兩個字符對應的 0 和 1 是固定的。

對於字符 ‘c’ 來講，提取字符串 「ab」 ，‘a’ 和 ‘b’ 不相等，相同的字符串的個數爲 0 ，0 + 1 = 1 ，因此 ‘c’ 對應的 next 值爲 1 ；

第四個字符 ‘a’ ，提取 「abc」 ，從首先 ‘a’ 和 ‘c’ 就不相等，相同的個數爲 0 ，0 + 1 = 1 ，因此，‘a’ 對應的 next 值爲 1 ；

第五個字符 ‘b’ ，提取 「abca」 ，第一個 ‘a’ 和最後一個 ‘a’ 相同，相同個數爲 1 ，1 + 1 = 2 ，因此，‘b’ 對應的 next 值爲 2 ；

第六個字符 ‘a’ ，提取 「abcab」 ，前兩個字符 「ab」 和最後兩個 「ab」 相同，相同個數爲 2 ，2 + 1 = 3 ，因此，‘a’ 對應的 next 值爲 3 ；

最後一個字符 ‘c’ ，提取 「abcaba」 ，第一個字符 ‘a’ 和最後一個 ‘a’ 相同，相同個數爲 1 ，1 + 1 = 2 ，因此 ‘c’ 對應的 next 值爲 2 ；

因此，字符串 「abcabac」 對應的 next 數組中的值爲（0,1,1,1,2,3,2）。

上邊求值過程當中，每次都須要判斷字符串頭部和尾部相同字符的個數，而在編寫算法實現時，對於某個字符來講，能夠借用前一個字符的判斷結果，計算當前字符對應的 next 值。

具體的算法以下：

模式串T爲(下標從1開始)：「abcabac」
next數組(下標從1開始)：    01

第三個字符 ‘c’ ：因爲前一個字符 ‘b’ 的 next 值爲 1 ，取 T[1] = ‘a’ 和 ‘b’ 相比較，不相等，繼續；因爲 next[1] = 0，結束。 ‘c’ 對應的 next 值爲1；（只要循環到 next[1] = 0 ,該字符的 next 值都爲 1 ）

模式串T爲：                  「abcabac」
next數組(下標從1開始)：011

第四個字符 ’a‘ ：因爲前一個字符 ‘c’ 的 next 值爲 1 ，取 T[1] = ‘a’ 和 ‘c’ 相比較，不相等，繼續；因爲 next[1] = 0 ，結束。‘a’ 對應的 next 值爲 1 ；

模式串T爲：                  「abcabac」
next數組(下標從1開始)：0111

第五個字符 ’b’ ：因爲前一個字符 ‘a’ 的 next 值爲 1 ，取 T[1] = ‘a’ 和 ‘a’ 相比較，相等，結束。 ‘b’ 對應的 next 值爲：1(前一個字符 ‘a’ 的 next 值) + 1 = 2 ；

模式串T爲：                  「abcabac」
next數組(下標從1開始)：01112

第六個字符 ‘a’ ：因爲前一個字符 ‘b’ 的 next 值爲 2，取 T[2] = ‘b’ 和 ‘b’ 相比較，相等，因此結束。‘a’ 對應的 next 值爲：2 (前一個字符 ‘b’ 的 next 值) + 1 = 3 ；

模式串T爲：                  「abcabac」
next數組(下標從1開始)：011123

第七個字符 ‘c’ ：因爲前一個字符 ‘a’ 的 next 值爲 3 ，取 T[3] = ‘c’ 和 ‘a’ 相比較，不相等，繼續；因爲 next[3] = 1 ，因此取 T[1] = ‘a’ 和 ‘a’ 比較，相等，結束。‘a’ 對應的 next 值爲：1 ( next[3] 的值) + 1 = 2 ；

模式串T爲：                  「abcabac」
next數組(下標從1開始)：0111232

算法實現：

#include <stdio.h>
#include <string.h>

void Next(char *T, int *next)
{
　　int i = 1;
　　next[1] = 0;
　　int j = 0;
　　while (i<strlen(T)) 
　　{
　　　　if (j==0 || T[i-1]==T[j-1]) 
　　　　{
　　　　　　i++;
　　　　　　j++;
　　　　　　next[i] = j;
　　　　}
　　　　else
　　　　{
　　　　　　j = next[j];
　　　　}
　　}
}

 

注意：在此程序中，next 數組使用的下標初始值爲 1 ，next[0] 沒有用到（也能夠存放 next 數組的長度）。而串的存儲是從數組的下標 0 開始的，因此程序中爲 T[i-1] 和 T[j-1]。

基於next的KMP算法的實現

先看一下 KMP 算法運行流程（假設主串：ababcabcacbab，模式串：abcac）。

第一次匹配：

匹配失敗，i 指針不動，j = 1（字符‘c’的next值）;

第二次匹配：

相等，繼續，直到：

匹配失敗，i 不動，j = 2 （ j 指向的字符 ‘c’ 的 next 值）;

第三次匹配：

相等，i 和 j 後移，最終匹配成功。

使用普通算法，須要匹配 6 次；而使用 KMP 算法，則只匹配 3 次。

實現代碼：

int KMP(char *S, char *T)
{
　　int next[10];
　　Next(T, next);　　//根據模式串T,初始化next數組
　　int i = 1;
　　int j = 1;
　　while (i<=strlen(S) && j<=strlen(T)) 
　　{
　　　　//j==0:表明模式串的第一個字符就和指針i指向的字符不相等；S[i-1]==T[j-1],若是對應位置字符相等，兩種狀況下，指向當前測試的兩個指針下標i和j都向後移
　　　　if (j==0 || S[i-1]==T[j-1]) 
　　　　{
　　　　　　i++;
　　　　　　j++;
　　　　}
　　　　else
　　　　{
　　　　　　j=next[j];//若是測試的兩個字符不相等，i不動，j變爲當前測試字符串的next值
　　　　}
　　}
　　if (j>strlen(T)) 
　　{
　　　　//若是條件爲真，說明匹配成功
　　　　return i-(int)strlen(T);
　　}
　　return -1;
}

 

KMP算法完整代碼

#include <stdio.h>
#include <string.h>

void Next(char *T, int *next)
{
　　int i = 1;
　　next[1] = 0;
　　int j = 0;
　　while (i<strlen(T)) 
　　{
　　　　if (j==0 || T[i-1]==T[j-1]) 
　　　　{
　　　　　　i++;
　　　　　　j++;
　　　　　　next[i] = j;
　　　　}
　　　　else
　　　　{
　　　　　　j = next[j];
　　　　}
　　}
}

int KMP(char *S, char *T)
{
　　int next[10];
　　Next(T, next);　　//根據模式串T,初始化next數組
　　int i = 1;
　　int j = 1;
　　while (i<=strlen(S)&&j<=strlen(T)) 
　　{
　　　　//j==0:表明模式串的第一個字符就和當前測試的字符不相等；S[i-1]==T[j-1],若是對應位置字符相等，兩種狀況下，指向當前測試的兩個指針下標i和j都向後移
　　　　if (j==0 || S[i-1]==T[j-1]) 
　　　　{
　　　　　　i++;
　　　　　　j++;
　　　　}
　　　　else
　　　　{
　　　　　　j = next[j];//若是測試的兩個字符不相等，i不動，j變爲當前測試字符串的next值
　　　　}
　　}
　　if (j>strlen(T)) 
　　{
　　　　//若是條件爲真，說明匹配成功
　　　　return i-(int)strlen(T);
　　}

　　return -1;
}

int main() 
{
　　int i = KMP("ababcabcacbab", "abcac");
　　printf("%d", i);

　　return 0;
}


運行結果：
6

 

升級版的next

注意：KMP 算法的關鍵在於 next 數組的肯定，其實對於上邊的KMP算法中的next數組，不是最精簡的，還能夠簡化。

例如：

模式串T：a b c a c
    next  ：0 1 1 1 2

在模式串「abcac」中，有兩個字符 ‘a’，咱們假設第一個爲 a1，第二個爲 a2。在程序匹配過程當中，若是 j 指針指向 a2 時匹配失敗，那麼此時，主串中的 i 指針不動，j 指針指向 a1 ，很明顯，因爲 a1==a2，而 a2！=S[i]，因此 a1 也確定不等於 S[i]。

爲了不沒必要要的判斷，須要對 next 數組進行精簡，對於「abcac」這個模式串來講，因爲 T[4] == T[next[4]] ，因此，能夠將next數組改成：

模式串T：a b c a c
    next  ：0 1 1 0 2

這樣簡化，若是匹配過程當中因爲 a2 匹配失敗，那麼也不用再判斷 a1 是否匹配，由於確定不可能，因此直接繞過 a1，進行下一步。

實現代碼：

void Next(char *T, int *next)
{
　　int i = 1;
　　next[1] = 0;
　　int j = 0;
　　while (i<strlen(T)) 
　　{
　　　　if (j==0 || T[i-1]==T[j-1]) 
　　　　{
　　　　　　i++;
　　　　　　j++;
　　　　　　if (T[i-1] != T[j-1]) 
　　　　　　{
　　　　　　　　next[i] = j;
　　　　　　}
　　　　　　else
　　　　　　{
　　　　　　　　next[i] = next[j];
　　　　　　}
　　　　}
　　　　else
　　　　{
　　　　　　j = next[j];
　　　　}
　　}
}

 

使用精簡事後的 next 數組在解決例如模式串爲「aaaaaaab」這類的問題上，會減小不少沒必要要的判斷次數，提升了KMP算法的效率。

例如：精簡前爲 next1，精簡後爲 next2：

模式串：a a a a a a a b
  next1：0 1 2 3 4 5 6 7
  next2：0 0 0 0 0 0 0 7

總結

KMP 算法，之因此比 BF 算法快的根本緣由在於：KMP 算法其實也和 BF 算法同樣，都是從主串開頭開始匹配，可是在匹配過程當中，KMP算法記錄了一些必要的信息。根據這些信息，在後續的匹配過程當中，跳過了一些無心義的匹配過程。