字符串匹配-KMP、BF算法

BF算法，即暴风(Brute Force)算法，是普通的模式匹配算法。KMP算法的核心思想其实就是为了让去匹配字符串的时候不去挨个的去查询，KMP算法比起BF算法好处就是为了让BF算法当中的没必要的回溯不要去发生

KMP算法比BF算法的时间复杂度降了很多，BF算法在最好的情况下时间复杂度是O（m+n）,而最坏情况下的时间复杂度是O(m*n)因为BF算法是要让i的位置回溯的，遇到不匹配的回溯到i-j+2，而KMP算法是不需要回溯的。KMP算法仅当模式串和主串直接有存在许多部分匹配的情况下，才显得比BF算法快。BF算法在一般情况下其实还是O（m+n），其中n代表原串的长度，而m代表模拟串的长度。KMP算法是建立在有一个next函数，next函数需要注意下。具体看代码解析。还有这里字符串的赋值也是需要注意的，已经定义了再赋值比如说 char s[100]，s[100]="abcd"这样是错误的得用strcpy函数。char s[100]="abcd"，或者char s[100]={'a','b','c','d'};这样也是可以的。

BF算法

int Index_BF(SString S,SString T,int pos)
{
    i=pos;//pos范围是1到S.length
    j=1;
    while(i<=S.length&&j<=T.length)
    {
        if(S.ch[i]==T.ch[j])
        {
            ++i;
            ++j;
        }
        else
        {
            i=i-j+2;//i回溯
            j=1;
        }
    }
    if(j>T.length)
        return i-T.length;//匹配成功
    else
        return 0;//匹配失败
    
}

KMP算法

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
int next[101];
typedef struct
{
    char ch[101];
    int length;
}SString;//结构体数组包括字符数组和字符串的长度
int Index_KMP(SString S,SString T,int pos)
{
    int i,j;
    i=pos;//从第pos个字符开始往后匹配pos的范围是1到S.length
    j=1;
    while(i<=S.length&&j<=T.length)
    {
        if(j==0||S.ch[i]==T.ch[j])/*若j==0就表示从原串第i+1的字符
        与模拟穿的第1的字符开始匹配*/
        {
            ++i;
            ++j;
        }
        else
        {
            j=next[j];/*此处就是表示如果原串和模拟串不匹配了，i不回溯了
                i应该和第next[j]个字符比较,这里next[j]代表的是前面有几个串
                和原串中前面几个串匹配，比如说原串是abaabaabcac,而模拟串是
                abaabc，这个时候本来匹配到第6个字符停下了。因为第6个字符前面的
                ab和模拟串当中的ab是一样的，所以应该是第6个字符和模拟串当中的第3个字符匹配*/
        }
    }
    if(j>T.length)
        return i-T.length;
    else
        return 0;
}
void get_next(SString T,int next[])
{
    /*next函数应该怎么求，以前一个next[j]为基础
    就比如说abaabcac，next[1]=0,next[2]=1，next[3]=1
    next[4]=2,next[5]=2,next[6]=3,因为在算到第2个字符，如果第二个字符
    就不匹配的，那就让i和第一个字符重新匹配，而第四个字符因为前面的第三个字符是和
    第一个字符一样的所以可以让第i个字符和next[4]个字符匹配就是看这个字符之前有几个和
    最前面的字符是相同的。*/
    int i,j;
    i=1;
    next[1]=0;
    j=0;
    while(i<T.length)
    {
        if(j==0||T.ch[i]==T.ch[j])
        {
            ++i;
            ++j;
            if(T.ch[i]!=T.ch[j])
                next[i]=j;
            else
                next[i]=next[j];
        }
        else
            j=next[j];
    }
}
int main()
{
    SString a,b;
    int n;
    strcpy(a.ch,"#acabaabccbcacaabc");
    strcpy(b.ch,"#abaabc");
    a.length=17;
    b.length=6;
    get_next(b,next);
    n=Index_KMP(a,b,1);
    printf("%d\n",n);//输出原串中开始匹配的位置，最后我这个样例输出的是3
    return 0;
}

关于KMP算法的next数组的求法的函数定义如下所示

当T="abcdex"的时候，关于next数组的求法如下所示，以及规律的总结

但其实这样的KMP算法的实现还是有缺陷的，我们需要去进行改进，其实就是去针对求next数组进行改进的，引用下书中的一个很好的例子

如果我们的主串S="aaaabcde"，子串T="aaaaax"，其next数组值分别为012345，在开始时，当i=5、j=5时，我们发现“b”与“a”不相等，如图5-7-6的①，因此j=next[5]=4，如图中的②，此时“b”与第4位置的“a”依然不等，j=next[4]=3，如图中的③，后依次是④⑤，直到j=next[1]=0时，根据算法，此时i++、j++，得到i=6、j=1，如图中的⑥

//改进的求next数组的算法
void get_nextval(String T,int *nextval)
{
    int i,j;
    i=1;
    j=0;
    nextval[1]=0;
    while (i<T[0]) {
        /* T[i]表示后缀的单个字符，T[j]表示前缀的单个字符 */
        if (j==0 || T[i] == T[j]) {
           
            ++i;
            ++j;
            if (T[i]!=T[j]) {
                nextval[i]=j;
            }
            else
                nextval[i]=nextval[j];
        }
        else
            j=nextval[j];
    }
}