1.什麼是KMP演算法

關於KMP演算法先看這麼一段英文解釋：

那KMP演算法到底是什麼呢？往下看：

在上一段文字中，通過匹配搜尋找到了KMP這個字串，這就是KMP演算法，其實就是一種匹配字串的演算法。
我們在主串中查詢一個字串，這個主串用S表示，將要查詢的字串稱作模式串，用T表示。

如上圖，要在主串S中找模式串T，如果使用樸素的模式匹配演算法，會有如下過程：
①模式串依次與主串中的字元匹配，若當前字元匹配上就匹配下一字元，直到全部配對成功

②若配對不成功，i需要回溯，將模式串整體後移一位(到回溯後的i位置)繼續①

可見，只要出現不匹配字元，i 就需要回溯，j 也需要回溯到1重新開始匹配，這種方法雖然能匹配出模式串，但過程很麻煩，且做了許多不必要的工作。針對這個問題，國外的大佬們提出了KMP演算法，利用匹配失敗後的資訊，儘量減少模式串與主串的匹配次數以達到快速匹配的目的。

KMP:

kmp的演算法核心在於發現字元不匹配時不回溯主串的 i 下標，僅僅靠回溯模式串的 j 下標，從而減少不必要的匹配過程。那當出現字元不匹配狀況時，模式串的j該回溯到哪呢？這就需要我們根據模式串生成一個next[]陣列，這個陣列儲存的數字告訴我們 j 該回溯到哪個位置。
next滿足：

現在假設我們已經根據模式串T得出了一個next[]陣列，我們利用這個next[]陣列來體驗一下KMP演算法：

當 i 指向3時發現不匹配，此時next = 1，所以 j 回溯指向1，重新匹配

j 回溯到1後仍然不匹配，所以 i 指向下一個位置4，重新匹配

i 指向8時發生不匹配，此時next=2 , 所以 j 回溯到2位置，重新匹配

程式碼示例：

   int KMP(char *S,char *T,int *next)//S代表主串，T代表模式串
{
    int i=1,j=1;
    int s_length=strlen(S)-1;//由於字串首位被佔，計算長度時需要減去一位
    int t_length=strlen(T)-1;
    while(i<=s_length&&j<=t_length)
    {
        if(j==0||S[i]==T[j])
        {
            ++i;
            ++j;
        }
        else
            j=next[j];//不相等j就回溯,若j回溯到0說明無相等字元
    }
    if(j>t_length)//若j超出模式串T的長度，說明已找到，匹配成功
        return i-t_length;//返回模式串在主串中的位置
    else
        return 0;
}   
 

從這個例子中可以看出由於 i 不需要回溯， j 按照next表回溯，所以省去了許多不必要的匹配過程，效率得以提高。下面介紹如何求得next陣列。

2.next陣列的求取:

（1）推導

例如要求模式串ababaaaba的next陣列

根據

①故當 j = 1 時，規定next[1]=0；
② j = 2 時，串取“a”，只有一個字元，屬於其他情況故 next[2]=1；

③ j = 3 時，串取“ab”，字串的字首=“a”，字尾=“b”，字首與字尾不相等，故屬其他情況，next[3]=1；

④ j = 4 時，串取“aba”，字串的字首取“a”，字尾取“a”時，字首與字尾相等，且長度為1，故 next[4]=1+1=2；

⑤ j = 5 時，串取“abab”，字串的字首取“ab”，字尾取“ab”時，字首與字尾相等，且長度為2，故 next[5]=2+1=3；

⑥ j = 6 時，串取“ababa”，字串的字首取“aba”，字尾取“aba”時，字首與字尾相等，且長度為3，故 next[6]=3+1=4；

⑦ j = 7 時，串取“ababaa”，字串的字首取“a”，字尾取“a”時，字首與字尾相等，且長度為1，故 next[7]=1+1=2；

⑧ j = 8 時，串取“ababaaa”，字串的字首取“a”，字尾取“a”時，字首與字尾相等，且長度為1，故 next[8]=1+1=2；

⑨ j = 9 時，串取“ababaaab”，字串的字首取“ab”，字尾取“ab”時，字首與字尾相等，且長度為2，故 next[9]=2+1=3；

最後求得next陣列

（2）程式設計

剛才的推導易於理解，但不適合設計成程式，接下來繼續以求模式串ababaaaba的next陣列為例，按照設計程式的思路來推導設計

①初始狀態如圖所示，T[ k ]為模式串T[ j ]的拷貝，j 初始值為1，k 初始值為0，令next[1]=0

② 此時 j = 1，k = 0 ; k=0時，next[j+1]=k+1=1;

③ j 、k右移一位, 此時 j = 2，k = 1。T[ j ]與T[ k ]不相等，k需要回溯到next[k]位置，即k=next[1]=0位置；

此時，k=0，故有next[j+1]=next[3]=1

④ j 、k右移一位, 此時 j = 3，k = 1。T[ j ]與T[ k ]相等，next[ j+1]= k+1=2 ，即next[4]=2

⑤ j 、k右移一位, 此時 j = 4，k = 2。T[ j ]與T[ k ]相等，next[ j+1]=k+1=3 ，即next[5]=3

⑥ j 、k右移一位, 此時 j = 5，k = 3。T[ j ]與T[ k ]相等，next[ j+1]=k+1=4 ，即next[6]=4

⑦ j 、k右移一位, 此時 j = 6，k = 4。T[ j ]與T[ k ]不相等，k需要回溯到next[k]位置，即k=next[4]=2位置；


此時 j = 6，k = 2。T[ j ]與T[ k ]不相等，k需要回溯到next[k]位置，即k=next[2]=1位置；

此時 j = 6，k = 1。T[ j ]與T[ k ]相等，next[ j+1]= k+1=2 ，即next[7]=2

⑧ j 、k右移一位, 此時 j = 7，k = 2。T[ j ]與T[ k ]不相等，k需要回溯到next[k]位置，即k=next[2]=1位置；


此時 j = 7，k = 1。T[ j ]與T[ k ]相等，next[ j+1]= k+1=2 ，即next[8]=2

⑨ j 、k右移一位, 此時 j = 8，k = 2。T[ j ]與T[ k ]相等，next[ j+1]=k+1=3 ，即next[9]=3

至此，next陣列求解成功。

程式碼示例：

void getNext(char *S,int *next)
{
    int j=1,k=0;
    next[1]=0;
    int s_length=strlen(S)-1;//由於字串首位被佔，計算長度時需要減去一位
    while(j<s_length)//注意此處i不能等於length,不然next[i+1]超出範圍
    {
        if(k==0||S[j]==S[k])
        {
            next[j+1]=k+1;
            ++k;
            ++j;
        }
        else
            k=next[k];//不相等j就回溯,若j回溯到0說明無相等字元
    }
}

（3）改進，nextval陣列的求取

我們發現，利用next陣列進行KMP匹配時任然會出現多餘的匹配步驟，於是提出了一種基於next陣列改進後的陣列nextval。
nextval陣列求取需要參考next陣列。核心在於：若無相等前後綴，維持原來的next[ j ]；若有後綴與字首相等，且字首在k處結束，nextval[ j ]= next[ k ]。

例如，上表中的模式串，
j = 1，nextval[1]=0；
j = 4，子串為“abab”，在此，可以取字尾“ab”與字首“ab”，他們相等，且字首最後一位“b” 在位置 j = 2處，故nextval[4 ] = next[ 2 ] = 1;
j = 6，指向字元“ababaa”，此處不存在相等的前後綴，所以維持原值，nextval[6 ] = next[ 6 ] =4

程式碼示例：

void getNextval(char *T,int *nextval)
{
    int i=1,j=0;
    nextval[1]=0;
    int s_length=strlen(T)-1;//由於字串首位被佔，計算長度時需要減去一位
    while(i<s_length)//注意此處i不能等於length,不然next[i+1]超出範圍
    {
        if(j==0||T[i]==T[j])
        {
            if(T[i+1]!=T[j+1])
                nextval[i+1]=j+1;//維持next
            else
                nextval[i+1]=nextval[j+1];//繼承
            ++j;
            ++i;
        }
        else
            j=nextval[j];//不相等j就回溯,若j回溯到0說明無相等字元
    }
}