KMP模式匹配算法

在写KMP之前，先把暴力匹配，也就是BF算法先写一下

int BF(string s,string t)
{
    unsigned int i,j;
    i=j=0;
    while(i<=s.size()-t.size())
    {
        for(int k=i;j<t.size();)
        {
            if(s[k]==t[j])
            {
                k+=1;j+=1;
            }
            else break;
        }
        if(j==t.size()) return i+1;
        else
        {
            i++;j=0;
        }
    }
    return 0;
}

BF算法思路非常简单，就是从第一位开始匹配，当出现不相同，就从下一位在开始匹配,最坏的情况是在000000000000001中找到001，每次匹配到最后一位才知道不匹配，然后又到下一位，然后匹配方案还在最后一位，复杂度为O（m.size（）*n.size（））。

而KMP通过引入next数组，来控制当某一位不匹配时，向前移动的位数，减少运算的消耗。

int get_next(string t,int *p)
{
    p=new int [t.size()];
    p[1]=p[0]=0;//第1位不匹配必然下一次从0位开始匹配
    int i,j;
    i=1;
    while(i<t.size())
    {
        int j=f[i];
        while(j>0 && t[i]!=t[j])//找到这一位向前多少位于前缀匹配
            j=f[j];
        f[i+1]= t[i]==t[j]?j+1:0;//如果找到相同的，就取j+1，不然，从0位开始匹配了
    }
}

接下来是KMP匹配算法实现

int KMP(string s,string t,int p)//从s【p】开始匹配t
{
    int i=p;
    int j=0;
    int next[100];
    get_next(t,next);
    while(i<s.size() && j<t.size()) //如果i和j没有越界
    {
        if(s[i]==t[j])//匹配到相等的，就向下一位移动
        {
            ++i;++j;
        }
        else           //不相等，就把j跳到之前的next对应的值上，因为t的正确的之前n位有与t开始的n位一致（n=next【j】）
            j=next[j];
    }
    if(j>=t.size()) return i-t.size();
    else return 0;
        
}

主要是next数组的理解开始学的时候理解错了，后来想通就好了，t就像是一个模具，在不断向右推进，然后KMP复杂度只有O（m+n）哦。

over--