KMP字符串查找算法

  KMP字符串模式匹配通俗點說就是一種在一個字符串中定位另外一個串的高效算法。簡單匹配算法的時間複雜度爲O(m*n)；而KMP算法，能夠證實它的時間複雜度爲O(m+n)。

 

1、簡單匹配算法

   先來一個簡單的匹配算法的函數。

int Index_BF(char const *S, char const *T, int pos)
{
    /*--------------本人修改-------------*/
    if(S == NULL || T == NULL)
    {
         return -1;
    }
    if(pos < 0 || pos > strlen(S) - strlen(T))
    {
         return -1;
    }
    /*------------------------------------*/

    //若串S中從第pos(S的下標0<= pos <=StrLength(S))個字符起存在和串T相同的子串，則匹配成功。
    //返回第一個這樣的子串在串S中的下標；不然返回-1
    int i = pos;
    int j = 0;
    while(S[i+j]!='\0' && T[j] != '\0')
    {
        if(S[i+j] == T[j])
        {
            j++;//繼續比較後一個字符
        }
        else
        {
            //從新開始新一輪的匹配
            i++;
            j=0;
        }
    }
    if(T[j] == '\0')
    {
        return i;//匹配成功，返回下標
    }
    else
    {
        return -1;//串S中(第pos個字符起)不存在和串T相同的子串
    }
}

 此算法的思想是直截了當的：將主串S中某個位置i起始的子串與模式串T相比較。即從j=0起比較S[i+j]與T[j]，如相等，則在主串S中存在以i爲起始位置匹配成功的可能性，繼續日後比較(j逐步加1)，直至與T串中最後一個字符相等爲止，不然改從S串的下一個字符起從新開始進行下一輪的「匹配」，即將串T向後滑動一位，即i增1，而j退回到0，從新開始新一輪的匹配。

 

   例如：在串S=「abcabcabdabba」中查找T=「abcabd」(咱們能夠假設從下標0開始)：先是比較S[0]和T[0]是否相等，而後比較S[1]和T[1]是否相等….咱們發現一直比較到S[5]和T[5]纔不等。如圖所示。

    當這樣一個失配發生時，T下標必須回溯到開始，S下標回溯的長度與T相同，而後S下標增1，而後再次比較。以下圖所示。

    此次馬上發生了失配，T下標又回溯到開始，S下標增1，而後再次比較。如圖所示。

   此次馬上發生了失配，T下標又回溯到了開始，S下標增1，而後再次比較。如圖所示。

   
    又一次發生了失配，因此T下標又回溯到了開始，S下標增1，而後再次比較。此次T中的全部字符和S中相應的字符匹配了。函數返回T在S中的起始下標3。如圖所示。

 

2、KMP算法

   仍是相同的例子，在S=「abcabcabdabba」中查找T=「abcabd」，若是使用KMP匹配算法，當第一次搜索到S[5]和T[5]不等後，S下標不是回溯到1，T下標也很多回溯到開始，而是根據T中T[5]=’d’的模式函數值(next[5]=2，爲何？後面講)，直接比較S[5]和T[2]是否相等，由於相等，S和T的下標同時增長；由於又相等，S和T的下標又同時增長…..最終在S中找到了T。如圖所示。

   KMP匹配算法和簡單匹配算法效率比較，一個極端的例子是：

   在S=「AAAAAA…AAB」(100個A)中查找T=「AAAAAAAAAB」，簡單匹配算法每次都是比較到T的結尾，發現字符不一樣，而後T的下標回溯到開始，S的下標也要回溯相同長度後增1，繼續比較。若是使用KMP匹配算法，就沒必要回溯。

   對於通常文稿中串的匹配，簡單匹配算法的時間複雜度可降爲O (m+n)，所以在多數的實際應用場合下被應用。

   KMP算法的核心思想是利用已經獲得的部分匹配信息來進行後面的匹配過程。看前面的例子，爲何T[5] ==‘d’的模式函數值等於2(next[5]=2)，起始這個2表示T[5]==‘d’的前面有兩個字符和開始的兩個字符相同，且T[5]==’d’不等於開始的兩個字符以後的第三個字符（T[2]=‘c’）。如圖所示。

 

 

   也就是說，若是開始的兩個字符以後的第三個字符也爲‘d’，那麼，儘管T[5]==‘d’的前面有2個字符和開始的兩個字符相同，T[5]==’d’的模式值也不爲2，而是爲0.

   前面我說：在S=「abcabcabdabba」中查找T=「abcabd」，若是使用KMP匹配算法，當第一次搜索到S[5] 和T[5]不等後，S下標不是回溯到1，T下標也不是回溯到開始，而是根 據T中T[5]==‘d’的模式函數值，直接比較S[5] 和T[2]是否相等。爲何能夠這樣？

   剛纔我又說：「（next[5]=2），其實這個2表示T[5]==‘d’的前面有2個字符和開始的兩個字符相同」。請看圖 ：由於，S[4] ==T[4]，S[3] ==T[3]，根據next[5]=2，有T[3]==T[0]，T[4] ==T[1]，因此S[3]==T[0]，S[4] ==T[1]（兩對至關於間接比較過了），所以，接下來比較S[5] 和T[2]是否相等。

 

   有人可能會問：S[3]和T[0]，S[4] 和T[1]是根據next[5]=2間接比較相等，那S[1]和T[0]，S[2] 和T[0]之間又是怎麼跳過，能夠不比較呢？由於S[0]=T[0]，S[1]=T[1]，S[2]=T[2]，而T[0] != T[1], T[1] != T[2],==> S[0] != S[1],S[1] != S[2],因此S[1] != T[0],S[2] != T[0]. 仍是從理論上間接比較了。

   有人疑問又來了，你分析的是否是特殊輕況啊。

   假設S不變，在S中搜索T=「abaabd」呢？

   答：這種狀況，當比較到S[2]和T[2]時，發現不等，就去看next[2]的值，next[2]=-1，意思是S[2]已經和T[0] 間接比較過了，不相等，接下來去比較S[3]和T[0]吧。

   假設S不變，在S中搜索T=「abbabd」呢？

   答：這種狀況當比較到S[2]和T[2]時，發現不等，就去看next[2]的值，next[2]=0，意思是S[2]已經和T[2]比較過了，不相等，接下來去比較S[2]和T[0]吧。

   假設S=「abaabcabdabba」在S中搜索T=「abaabd」呢？

   答：這種狀況當比較到S[5]和T[5]時，發現不等，就去看next[5]的值，next[5]=2，意思是前面的比較過了，其中，S[5]的前面有兩個字符和T的開始兩個相等，接下來去比較S[5]和T[2]吧。

   總之，有了串的next值，一切搞定。那麼，怎麼求串的模式函數值next[n]呢？（本文中next值、模式函數值、模式值是一個意思。）

 

3、怎麼求串的模式值next[]

定義：

   (1) next[0] = -1

   意義：任何串的第一個字符的模式值規定爲-1。

   (2) next[j] = -1

   意義：模式串T中的下標爲j的字符，若是與首字符相同，且j的前面的1-k個字符與開頭的1-k個字符不等（或者相等但T[k]==T[j]，1<=k<j）

   (3) next = k

   意義：模式串T中下標爲j的字符，若是j的前面k個字符與開頭的k個字符相等，且T[j] !=T[k]，1<=k<j。

   (4) next[j] = 0

   意義：除（1）、（2）、（3）的其餘狀況。

   

舉例：

   01）求T=「abcac」的模式函數的值

     next[0] = -1 根據（1）

    next[1] = 0 根據（4） 因（3）有1<=k<j；不能說，j=1，T[j-1]==T[0]

    next[2] = 0 根據（4） 因（3）有1<=k<j；（T[0]=a）!= （T[1]=b）

    next[3] =-1 根據（2） 

     next[4] = 1 根據(3) T[0]=T[3] 且 T[1]=T[4]

 

   
    爲何T[0] == T[3]，還會有next[4] = 0呢？由於T[1]==T[4]，根據（3）且T[j]!=T[k]被劃入（4）。

   
    02）來點複雜點的，求T=「ababcaabc」的模式函數的值。

    next[0] = -1 根據（1）

    next[1] = 0 根據（4）

    next[2] = -1 根據（2）

    next[3] = 0 根據（3）雖T[0]=T[2] 但T[1]=T[3]被劃入了（4）

    next[4] = 2 根據（3）T[0]T[1]=T[2]T[3] 且T[2]!=T[4]

    next[5] = -1 根據（2）

    next[6] = 1 根據（3）T[0]=T[5] 且T[1]!=T[6]

    next[7] = 0 根據（3）雖T[0]=T[6] 但T[1]=T[7]被劃入（4）

    next[8] = 2 根據（3）T[0]T[1]=T[6]T[7] 且T[2]!=T[8]

    既： 

   只要理解了next[3]=0，而不是=1，next[6] =1，而不是=-1，next[8]=2，而不是=0，其餘的好像都容易理解。

   03）來個特殊的，求T=「abCabCad」的模式函數的值。

 

     next[5] = 0 根據（3） 雖T[0]T[1]=T[3]T[4]，但T[2]=T[5]

    next[6] = -1 根據（2） 雖前面有abC=abC，但T[3]==T[6]

    next[7] = 4 根據（3） 前面有abCa=abCa，且T[4]!=T[7]

   04）若T[4]==T[7]，即T=」 adCadCad」,那麼將是這樣：next[7]=0, 而不是= 4,由於T[4]==T[7]。

 

   若是你以爲你懂了，那麼，進行一個小的練習。

  

練習：求T=」AAAAAAAAAAB」的模式函數值，並用後面的求模式函數值函數驗證。

   

意義：

   next函數值究竟有什麼含義呢？前面說過一些，這裏總結：

   設在字符串S中查找模式串T，若S[m]!=T[n]，那麼，取T[n]的模式函數next[n],

   (1) next[n] = -1 表示S[m]和T[0]間接比較過了，不相等，下一次比較S[m+1]和T[0]

   (2) next[0] = 0  表示比較過程當中產生了不相等，下一次比較S[m]和T[0]

   (3) next[n] = k>0 && k<n 表示S[m]的前k個字符與T中的開始的k個字符已經間接的比較相等了，下一次比較S[m]和T[k]相等嗎？

   (4) 其餘值，不可能。

 

4、KMP算法的實現

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

/*功能：求模式串值
 *參數：ptn：模式串
 *nextval：保存模式串值的數組
 */
void get_nextval(char const *ptn, int *nextval)
{
    int i = 0;
    nextval[0] = -1;
    int j = -1;
    int plen = strlen(ptn);

    if(ptn == NULL || nextval == NULL)
    {
        return;
    }
    while(i < plen)
    {
        if(j == -1 || ptn[i] == ptn[j])
        {
            ++i;
            ++j;
            if(ptn[i] != ptn[j])
            {
                nextval[i] = j;
            }
            else
            {
                nextval[i] = nextval[j];
            }
        }
        else
        {
            j = nextval[j];
        }
    }
}

/*功能：實現KMP算法
 *參數：src：源串
 *      patn：模式串
 *      nextval：模式串值
 *      pos：源串開始的位置
 *返回值：若匹配成功，則返回下標；若出錯或匹配不成功，則返回-1
 */
int kmp_search( char const *src, char const *patn, int const *nextval,int pos)
{
    int i = pos;
    int j = 0;
    if(src == NULL || patn ==NULL)
    {
        return -1;
    }
    int slen = strlen(src);
    int plen = strlen(patn);

    if(pos < 0 || pos > slen)
    {
        return -1;
    }

    while(i < slen && j < plen)
    {
        if(j == -1 || src[i] == patn[j])
        {
            ++i;
            ++j;
        }
        else
        {
            j = nextval[j];
            //當匹配失效時，直接用p[j_next]與s[i]比較
            //下面闡述怎麼求這個值，即匹配失效後的下一次匹配的位置
        }
    }
    if( j >= plen)
    {
        return i - plen;//返回下標，從0開始
    }
    else
    {
        return -1;
    }
}

int main()
{
    char src[] = "aabcabcebafabcabceabcaefabcacdabcababce";
    char prn[] = "abce";

    int *nextval = (int *)malloc(sizeof(int)* strlen(prn)); 
    get_nextval(prn,nextval);
    int i =0;
    for(i = 0; i < strlen(prn); i++)
    {
        printf("%d ",nextval[i]);
    }
    printf("\n");
    printf("the result is : %d\n",kmp_search(src, prn, nextval,5));
    
    return 0;
}

 

   KMP的時間複雜度爲O(n + m)，空間複雜度爲O(m)。

   簡單字符串匹配算法的時間複雜度爲O(n*m)，空間複雜度爲O(1)。

   其中，n爲原串的長度，m爲模式串的長度。