KMP字符串查找算法

   KMP字符串模式匹配通俗点说就是一种在一个字符串中定位另一个串的高效算法。简单匹配算法的时间复杂度为O(m*n)；而KMP算法，可以证明它的时间复杂度为O(m+n)。

一、简单匹配算法

   先来一个简单的匹配算法的函数。

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。如图所示。

二、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值、模式函数值、模式值是一个意思。）

三、怎么求串的模式值next[]

定义：

   (1) next[0] = -1

   意义：任何串的第一个字符的模式值规定为-1。

   (2) next[j] = -1

   意义：模式串T中的下标为j的字符，如果与首字符相同，且j的前面的1-k个字符与开头的1-k个字符不等（或者相等但T[k]==T[j]，1<=k

   (3) next = k

   意义：模式串T中下标为j的字符，如果j的前面k个字符与开头的k个字符相等，且T[j] !=T[k]，1<=k

   (4) next[j] = 0

   意义：除（1）、（2）、（3）的其他情况。

   

举例：

   01）求T=“abcac”的模式函数的值

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

    next[1] = 0 根据（4） 因（3）有1<=k

    next[2] = 0 根据（4） 因（3）有1<=k

    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

   (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为模式串的长度。

 

   说明：

   先前看关于字符串匹配的相关算法，KMP算法肯定是不能落下的，知道模式串next[]数组比较难理解，所以，从网上、书上查找资料，发现了几篇讲述next[]和KMP算法非常容易理解的文章，再加上自己的罗嗦和修改，才有了下面的文字，记录下来，仅仅是为了自己以后回头看的方便，别无它意，如果能为他人带来参考，那样更好。我无意侵犯前辈的权益，如果您们感觉有所侵犯，请及时通知，我会删除相应文字。

   再次对您们的贡献表示感谢！

                                                             梦醒潇湘

            2012-10-9 16:06