KMP算法原理

KMP算法指在主串S中有与模式串T一样的字符串,找出主串中从第pos个位置开始与模式串相匹配的位置的前一个位置
最慢的KMP算法和最简单的BF算法时间复杂度是一样的,
原理:
字符位置: 1 2 3 4 5 6 7 8 9
例主串S : a b a b c d c d e
模式串T : a b c
第三个位置不匹配,如果是BF算法,则模式串T向后移动一位,直到找出相等的字符串
而KMP算法可以直接将T串移动2位,形成:
字符位置: 1 2 3 4 5 6 7 8 9
例主串S : a b a b c d c d e
模式串T : -----a b c
为什么呢?
因为模式串中a b 之前已经匹配过了,如果T只向后移动一位,则还是会与S不匹配,要看T中与S中已经匹配的字符数量.
这里要引用到前缀和后缀的概念
位置i:1 2 3 4 5 6 7 8
例T: a b c d f a b c
这个模式串的前缀有" “,“a”,“ab”,“abc”,“abcd”,“abcdf”,“abcdfa”,“abcdfb”,从第一个字符开始,不能包括最后一个字符,即不能是全部字符,后缀有” “,“c”,“bc”,“abc”,“fabc”,“dfabc”,“cdfabc”,“bcdfabc"从最后一个开始往前追溯,不能包括最前面的一个,
前缀和后缀不包括T[i]本身
用next[i]来表示前缀和后缀中最长重复的长度 + 1
规定next[0] = -1,代表没有相同的前缀和后缀
当i = 1时,字符串为"a b”,T[1] == b,b不算入前缀和后缀中,前缀为a,后缀为b,不相等,重复长度为0,记next[1] = 0+1 = 1;
当i = 2时,字符串为"a b c”,前缀为"a",“a b”,后缀为"c “,“b c”;没有相同的前缀和后缀,重复长度为0,记next[2] = 0+1 = 1;
…
当i = 6时,字符串为"a b c d f a b”,其中,有前缀"a",与后缀"a"相等,其余再无相等的情况,所以最长匹配长度为1,next[6] = 1+1 = 2;
当i = 7时,无相等的前后缀,next[7] = 1;

-位----置 i 1 2 3 4 5 6 7 8 9
-模式串 T a b c a a b b a b
-----next[i] 0 1 1 1 2 2 3 3 2

注:next[i],i是对模式串而言的位置
向后移动的步数 = i - next[i]
例:初始
位----置 j:1 2 3 4 5 6 7 8 9 10 11
—主串S:A B A D A B A B A B G
模式串T:A B A B G
位----置i:1 2 3 4 5
因为从主串开始与模式串不匹配的那个字符为S[4],模式串为T[4],只有一个前后缀相同,所以next[4] = 1+1=2如果往后移,必定是
位----置 j:1 2 3 4 5 6 7 8 9 10 11
—主串S:A B A D A B A B A B G
模式串T:------A B A B G
位----置i:------1 2 3 4 5
后移了2位,模式串中A与字串中A相匹配,匹配的个数就是1,再加1就是加T[4]本身这个,所以移动步数就是:总长度4-(相匹配的前后缀个数1+本身1 == next[4])
即:移动步数 = i - next[i]

例:初始
—主串:A B A D A B A B A B G
模式串:A B A B G
从主串第四个位置不相等,模式串前四个位置 A B A B最大重复前后缀长度为1,(不包括最后的B),所以next[4] = 1+1 = 2;即向后移动4 - next[4] = 2个位置,模式串中的A与主串中的A匹配了,

第一步:
—主串-A B A D A B A B A B G
模式串:------A B A B G
从主串第四个位置不相等,next[2] = 0+1 = 1;所以向后移动2 - next[2] = 1步

第二步:
—主串-A B A D A B A B A B G
模式串:--------A B A B G
从主串第四个位置不相等,由于next[1] = 0,所以再向后移动一步,(next[1] = 0,就是向后移动一步)

第三步:
—主串-A B A D A B A B A B G
模式串:-----------A B A B G
从主串第9个位置不相等,next[5] = 2 + 1 = 3,向后移动5 - next[3] = 2步,

第四步:
—主串-A B A D A B A B A B G
模式串:----------------A B A B G
匹配
如果是用BF算法,需要移动主串长度(11-5)次,每次都要与模式串重新比较,此方法比BF简单一些,但是仍然有不足之处,其实第1步可以省去,直接变成第二步,nextval[i]就是对next再简化之后的存储方式,可以让此步省略,

nextval[i]的算法
next[i]与T[i]比较,不相等,next[i] = nextval[i],不相等,再继续往前比较,
以上面串为例
,当i = 1,next[1] = 0,没有i = 0的字符,所以nextval = next;
当i = 2,next[2] = 1,字符T[2] = b与第一个字符T[1] = a比较,b != a,所以next[2] = nextval[2];
当i = 3,next[3] = 1,第三个字符c与第一个字符a比较,c != a,所以next[2] = nextval[2];
当i = 4,next[4] = 1,第四个字符a与第一个字符a相等,所以往前推,next[1] = 0,没有再前面的字符,所以next[4] = nextval[1] = 0
…
当i = 6,next[6] = 2,第六个字符b与第二个字符b相等,往前推,next[2] = 1,第二个字符b与第一个字符a不相等所以去 nextval[6] = next[2] = 1;

-位----置 i 1 2 3 4 5 6 7 8 9
-模式串 T a b c a a b b a b
-----next[i] 0 1 1 1 2 2 3 3 2
-nextval[i] 0 1 1 0 2 1 3 1 1

以下是代码块:

#include "stdio.h"
#include "string.h"
//KMP算法时间复杂度O(m+n) 
void cal_next(char *str, int *next, int len)
{
    next[0] = -1;//next[0]初始化为-1，-1表示不存在相同的最大前缀和最大后缀
    int k = -1;//k初始化为-1
    for (int q = 1; q <= len-1; q++)
    {
        while (k > -1 && str[k + 1] != str[q])//如果下一个不同，那么k就变成next[k]，注意next[k]是小于k的，无论k取任何值。
        {
            k = next[k];//往前回溯
        }
        if (str[k + 1] == str[q])//如果相同，k++
        {
            k = k + 1;
        }
        next[q] = k;//这个是把算的k的值（就是相同的最大前缀和最大后缀长）赋给next[q]
    }
}

int KMP(char *str, int slen, char *ptr, int plen)
{
    int *next = new int[plen];
    cal_next(ptr, next, plen);//计算next数组
    int k = -1;
    for (int i = 0; i < slen; i++)
    {
        while (k >-1&& ptr[k + 1] != str[i])//ptr和str不匹配，且k>-1（表示ptr和str有部分匹配）
            k = next[k];//往前回溯
        if (ptr[k + 1] == str[i])
            k = k + 1;
        if (k == plen-1)//说明k移动到ptr的最末端
        {
            //cout << "在位置" << i-plen+1<< endl;
            //k = -1;//重新初始化，寻找下一个
            //i = i - plen + 1;//i定位到该位置，外层for循环i++可以继续找下一个（这里默认存在两个匹配字符串可以部分重叠）
            return i-plen+1;//返回相应的位置
        }
    }
    return -1;  
}

int main(){
	char str[40] = "adfgfabbbcdejjjfdhgj";
    char ptr[10] = "abbb";
    printf("主串:adfgfabbbcdejjjfdhgj\n");
    printf("字串:abbb\n") ;
    int a = KMP(str, 40, ptr, strlen(ptr));
    printf("从第%d个位置后匹配",a);
    return 0;
}

测试区