字符串查找算法BF、KMP详解

字符串查找：

BF算法：

（朴素查找算法）

当查找不成功时，主串返回刚刚起始字符的下一个，子串返回第一个字符位置

时间复杂度：O(n*m)

int BF(const char* str, const char* sub, int pos)//pos开始查找的位置
{
    assert(str!=NULL && sub!=NULL);
    if(pos<0)
    {
        pos=0;
    }
    int lenstr=strlen(str);
    int lensub=strlen(sub);
    int i=pos;
    int j=0;
    while(i<lenstr && j<lensub)
    {
        if(sub[i]==str[j])
        {
            i++;
            j++;
        }
        else
        {
            i=i-j+1;
            j=0;
        }
    }
    if(j>=lensub)//只要子串都走完就是找到
    {
        return i-j;
    }
    else
    {
        return -1;
    }
}

• BF算法很简单，只需记得失配后子串回退到第一个字符，主串回退到上次开始匹配的字符的下一个；主串为什么要回退：

如图，在红线处失配后，如果i 不回退，那么将匹配失败，但其实可以成功，只是因为i 不回退导致了漏配。

KMP算法：

static void Get(const char* sub, int *next)
{
    int lensub=strlen(sub);//算出每一个字符的K 值
    int next[0]=-1;
    int next[1]=0;
    int j=1;
    int k=0;
    while(j+1<lensub)
    {
        if(k==-1 || sub[j]==sub[k])
        {
            next[j+1]=k+1;
            j++;
            k++;
        }
        //修正后
        /*if(k==-1 || sub[j]==sub[k])
        {
            ++j;
            ++k;
            if(sub[j]!=sub[k]) 
            {
            	next[j]=k; 
            }
            else 
            {
            	next[j]=next[k];
            }
        }*/
        else
        {
            k=next[k];
        }
    }
}


int KMP(const char* str, const char* sub, int pos)
{
    assert(str!=NULL && sub!=NULL);
    if(pos<0)
    {
        pos=0;
    }
    int *next=(int*)malloc(sizeof(int));
    Get(sub, next);
    if(next==NULL)
    {
        printf("error");
        return -2;
    }
    
    int lenstr=strlen(str);
    int lensub=strlen(sub);
    int i=pos;
    int j=0;
	while(i<lenstr && j<lensub)
    {
        if(j==-1 || sub[j]==str[i])
        {
            i++;
            j++;
        }
        else
        {
            //i不回退
            j=next[j];
        }
    }
    free(next);
    if(j>=lensub)
    {
        return i-j;
    }
    else
    {
        return -1;
    }
}

KMP算法时间复杂度只有O(n+m)，原因是i 不回退，j每次回退到下标k 位置处，再次匹配就会成功，所以框架和BF类似，核心算法就是寻找k 位置。

1、首先来说为什么i 不需要回退：

P：主串

S：模式串

如图，当在红线位置失配时，在i, j 都回退后，再次匹配时，i 还是会到之前的位置(如果不理解的话可以根据BF的算法自己在纸上画一下，就会发现i 的回退是多余的，重复的，对于BF算法提到的特殊情况也是一样的道理)

如图，在红线失配后，按照KMP算法，i 不会退，j 只需要回退到(k=2)位置处，接下来即可匹配成功，大大降低了时间复杂度，所以接下来就需要计算K值。

在失配前：

因为两个字符串相等的话长度也相等，所以下标差值肯定相等即可推出。

假设此时主串应该与模式串中第k（该例中k = 2）个字符继续比较,也就是说j 回退到该位置就可以匹配成功，那么模式串中k-1 个字符肯定满足：

根据（1）式，可以构造出：

因为k<j，所以Si-k...Si-1肯定是Si-j...Si-1的子串，Px...Pj-1肯定也是P0...Pj-1的子串，所以相等字符串的子串只要二者对应长度相等那么这两个子串也相等。

根据（2）（3）推出：

则在子串失配前找到两个相等的真子串，且满足如下特点：

1、一个串以P0做为开头

2、另一个串以失配前的最后一个字符作为结尾

k就是该真子串的长度。

• 那么对于每一个字符（每一个字符都有失配的可能）都有一个相应的k 值，存放在next[]数组中，当失配时，就取在next数组中相应的k值，现在就需要构建next数组。

规定字符串前两个的k 值为-1，0（也可以0,1需要修改相应代码），计算K 值的原理就是根据已经规定的K 的值来计算后面字符的K 值，这里有两种情况：

1、Pk==Pj:

根据推导可以看出Pk==Pj，就等于直接给满足条件的前后两个真子串长度各加一个相同字符，自然而然k 也就加 1，所以next[j+1]=k+1;

2、Pk!=Pj:

此时可以将求next 函数值的问题又看成一个模式匹配的问题，只不过此时的模式串是主串，子串是模式串的子串

（P0...Pk）

k=next[k],前部分的next数组已经构建，所以是直接获取值，之后继续匹配，在该算法中k 值会被置为-1，所以要加判断。

此时还可以继续优化该算法，因为当前算法在某些情况下还有缺陷：

如图，下标为3处失配，按照next数组，还需要i = 3, j = 1; i=3, j=0; i=3,j=-1,这三次比较，实际上，因为模式串中前四个字符都相等，因此不需要再和主串第四个字符比较，而是将模式串直接向右滑动4个字符的位置，直接和主串第五个字符比较即可。

当next[j]==k,模式串中Pj==Pk时，对于主串如果Sj != Pj ，就不需要再和Pk比较，而是和Pnext[k]比较，此时next[j]应该等于next[k]

• BF算法和KMP算法在一般情况下，BF其实近似于KMP，所以BF由于其简单易懂仍在被沿用，但是当主串与模式串存在许多“部分匹配”的情况下KMP算法就会快很多(因为对于BF，主串与模式串总是在匹配部分后i,j又要回退，这样的次数增多就会耗时)；

• 由于KMP只需对于主串从头到尾扫描一遍，所以对处理从外设输入的庞大文件很有效，可以边读边匹配，无需回头重读；