字符串匹配算法之KMP算法

一个主字符串S，一个模式字符串T，要求在主字符串中匹配模式字符串，匹配成功则返回主字符串中和模式字符串匹配成功的第一个字符的位置，否则返回-1。

字符串匹配简单算法

一个简单的算法思路为：从主串的第pos个字符起和模式串中的第一个字符比较，若相等，则继续比较下一个字符；若某一个字符不相等，则从主串的pos+1个字符起和模式串中的第一个字符再重新比较，依此类推。若成功则返回第一个字符的位置，否则返回-1.
代码如下：

#include<iostream>
#include<string>
using namespace std;
int index_bf(string S,string T,int pos)
{
    int i = pos;
    int j = 0;
    int size_S = S.size ();
    int size_T = T.size ();
    while(i-j+size_T <= size_S && j!=size_T)
    {
        if(S[i]==T[j])
        {
            i++;
            j++;
        }
        else
        {
            i=i-j+1;
            j=0;
        }
    }
    if(j==size_T)
        return i-j;
    else
        return -1;
}

int main()
{
    string S = "abcabcabdabba";
    string T = "abcabd";
    int pos = index_bf(S,T,0);
    cout<<pos<<endl;
    return 0;
}

匹配的过程如下：
第一轮：

第二轮：

第三轮：

第四轮：

第四轮匹配成功，函数返回匹配成功的第一个字符的下标，即3.

在这个算法中，只要某次匹配不成功，则T的下标j需要回溯到0，而S的下标i也回溯同样的距离，然后S的下标i加1，从而再次开始匹配。这是一种效率较低的做法，一种改进的算法是KMP算法。

---

KMP算法

在KMP算法中，当某次匹配过程中出现不等时，不需要回溯指针i，而是利用已经得到的部分匹配的结果将字符串向右“滑动”尽量远的一段距离，继续进行比较。
如上面的例子，当第一次匹配到i=5，j=5时，出现不等，S的下标不需要回溯到1，j的下标也不需要回溯到0，而是i继续保持5，j的值变为2（因为next[5]=2），比较S[5]和T[2]。

该算法的一个关键是next函数值。
next函数值的定义为：
1）next[0]= -1
任何串的第一个字符的模式值规定为-1

2）next[j]= -1
模式串T中下标为j的字符，如果与首字符相同，且j的前面的1—k个字符与开头的1—k个字符不等（或者相等但T[k]==T[j]）（1 ≤ k < j）。如：T=”abCabCad” 则 next[6]=-1，因为T[6]=T[0]，T[3]=T[6]

3）next[j]=k
模式串T中下标为j的字符，如果j的前面k个字符与开头的k个字符相等，且T[j] != T[k] （1 ≤ k < j）。即T[0]T[1]T[2]。。。T[k-1]==T[j-k]T[j-k+1]T[j-k+2]…T[j-1]且T[j] != T[k].（1 ≤ k < j）

4）next[j]=0
剩下的其他情况。

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[n]=0 表示比较过程中产生了不相等，下一次比较 S[m] 和T[0]。
3）next[n]= k （0 < k < n），表示S[m]的前k个字符与T中的开始k个字符已经间接比较相等了，下一次比较S[m]和T[k]。

next函数值的求取只与模式串有关，程序如下：

void get_next(const string T, int * next)
{
    int j = 0;
    int k = -1;
    next[0] = -1;
    int len=T.size ();
    while( j < len-1 )
    {
        if (k == -1 || T[j] == T[k])
        {
            ++j;
            ++k;
            if (T[j]!=T[k])
                next[j] = k;
            else
                next[j] = next[k];
        }
        else
            k = next[k];
    }
}

获得next函数值后，就可以根据next的值来进行字符串匹配

int KMP(const string S,const string T)
{
    int tlen = T.size ();
    int slen = S.size ();
    int *next=new int[tlen];
    get_next(T,next);  //求next函数值

    int index=0,i=0,j=0;
    while(i<slen && j<tlen)
    {
        if(S[i]== T[j])
        {
            ++i;  //继续比较后继字符
            ++j;
        }
        else
        {
            index += j-next[j];
            if(next[j]!=-1)
                j=next[j];  //模式串向右移动
            else
            {
                j=0;
                ++i;
            }
        }
    }  
    delete[] next;
    if(j==tlen)
        return index;  //匹配成功
    else
        return -1;      
}

综合上面的程序，为：

#include<iostream>
#include<string>
using namespace std;

void get_next(const string T, int * next)
{
    int j = 0;
    int k = -1;
    next[0] = -1;
    int len=T.size ();
    while( j < len-1 )
    {
        if (k == -1 || T[j] == T[k])
        {
            ++j;
            ++k;
            if (T[j]!=T[k])
                next[j] = k;
            else
                next[j] = next[k];
        }
        else
            k = next[k];
    }
}

int KMP(const string S,const string T)
{
    int tlen = T.size ();
    int slen = S.size ();
    int *next=new int[tlen];
    get_next(T,next);  //求next函数值

    int index=0,i=0,j=0;
    while(i<slen && j<tlen)
    {
        if(S[i]== T[j])
        {
            ++i;  //继续比较后继字符
            ++j;
        }
        else
        {
            index += j-next[j];
            if(next[j]!=-1)
                j=next[j];  //模式串向右移动
            else
            {
                j=0;
                ++i;
            }
        }
    }  
    delete[] next;
    if(j==tlen)
        return index;  //匹配成功
    else
        return -1;      
}

int main()
{
    string S = "abcabcabdabba";
    string T = "abcabd";
    int pos = KMP(S,T);
    cout<<pos<<endl;
    return 0;
}

参考整理自：http://blog.csdn.net/lin_bei/article/details/1252686