数据结构与算法 ---- KMP算法（串模式匹配算法）

KMP算法是对BF算法的改进，利用了在匹配过程中得到的信息跳过不必要的匹配，从而达到一个较高的匹配效率。

next数据

next数组是用来记录模式串弟j位和主串第i位匹配失败时，模式串需要移到k位继续主串第i位匹配。
next数组实际上记录的是模式串每一位前面的最长可匹配后缀和最长可匹配前缀，上图：

实现流程

第一次匹配：

匹配失败，i指针不动，j=2(next[3]的值)

第二次匹配：

匹配失败，i指针继续不动，j=1(next[2]的值)

第三次匹配：

匹配失败，i指针继续不动，j=0(next[1]的值)

第四次匹配：

匹配失败，j=-1(next[0]的值)，当j=-1时，i加1移向下一位即i++

第五次匹配：

匹配失败，j=0(next[1]的值)，i不动

第六次匹配：

匹配失败，j=-1(next[0]的值)，i和j都加1

第七次匹配：

匹配成功！！

发现：从过程看似乎和BF算法没有区别，这是因为含有连续重复字符的字符串导致的，换成不会连续重复大的字符串就可以看出效果了，因此KMP算法可以进一步优化

KMP优化

从next数组下手

原来next数组代码：

//求next数组
void getNext()
{
    int i = 0; //pattern串的下标
    int j = -1; //
    next[0] = -1;
    while (i < pattern_len - 1)
    {
        if (j == -1 || pattern[i] == pattern[j])
        {
            ++i;
            ++j;//i,j相加之后pattern[0..j-1]和pattern[i-j....i-1]是相等的
            next[i] = j;//pattern[i]位字符匹配不成功时应该重新回到pattern[j]位进行匹配
        }
        else
            j = next[j];
    }
}

改进代码

//优化算法，求next数组的值
void getNext2()
{
    int i = 0; //pattern串的下标
    int j = -1; //
    next[0] = -1;
    while (i < pattern_len - 1)
    {

        if (j == -1 || pattern[i] == pattern[j])
        {
            ++i;
            ++j;
            if (pattern[i] != pattern[j]) //正常情况
                next[i] = j;
            else //特殊情况，这里即为优化之处。考虑下AAAB, 防止4个A形成012在匹配时多次迭代。相当于next[3]=next[2]=next[1]=next[0]=-1
                next[i] = next[j];
        }
        else
            j = next[j];
    }
}

改进后的next数组：

完整代码：

#include <stdio.h>
#include <string.h>

//求next数组
void getNext(char *T, int *next)
{
    int i = 0; //pattern串的下标
    int j = -1; //
    next[0] = -1;
    int pattern_len = strlen(T);
    while (i < pattern_len - 1)
    {
        if (j == -1 || T[i] == T[j])
        {
            ++i;
            ++j;
            if (T[i] != T[j]) //正常情况
                next[i] = j;
            else //特殊情况，这里即为优化之处。考虑下AAAB, 防止4个A形成012在匹配时多次迭代。相当于next[3]=next[2]=next[1]=next[0]=-1
                next[i] = next[j];
        }
        else
            j = next[j];
    }
}

int kmp(char * str,char * T)
{//字符串比较过程
    int i = 0, j = 0;
    int next[10];
    int str_len = strlen(str);
    int pattern_len = strlen(T);
    getNext(T,next); // 计算next数组;
    while (i < str_len && j < pattern_len)
    {
        if (j == -1 || str[i] == T[j])
        {
            ++i;
            ++j;
        }
        else
            j = next[j];
    }
    if (j >= pattern_len)
        return i - pattern_len;
    else
        return -1;
}

int main() 
{
	int i=kmp("aaababaaaca","aaac");
    printf("%d",i);
    return 0;
}

总结

KMP算法比BF算法高效在于它减少了一些比必要的匹配，当时当字符串有连续重复的字符时，KMP算法难以体现高效性，需要对KMP算法进一步优化