KMP算法总结-CSDN博客

本文链接：https://blog.csdn.net/blue_been/article/details/8299696

大多的浏览器都有在网页中需找关键字的功能。

这个功能的实现涉及到字符串的匹配算法。

在大学中数据结构考试的时候大家对KMP算法一定是深恶痛绝。不过事物往往是有其两面性的。

如今KMP就成为了我的救世主。

首先对比下普通字符串匹配BF算法与KMP算法的效率。

设：原始串是S，模式串是T。

时间复杂度： BF算法是O(strlen(S) * strlen(T))。

KMP算法是O(strlen(S) + strlen(T))。

空间复杂度： BF算法是O(1)。

KMP算法是O(strlen(T))。

现在明显的看出KMP在时间上的优越性了吧。对于KMP比BF稍差的空间复杂度，相信大多的硬件设备是可以提供足够的空间的。

对比下普通字符串匹配BF算法与KMP算法的匹配方式

BF算法中，如果当前字符匹配成功，即s[i+j] == T[j]，令j++，继续匹配下一个字符；如果失配，即S[i + j] != T[j]，需要让i++,并且j= 0，即每次匹配失败的情况下，模式串T相对于原始串S向右移动了一位。

而KMP算法中，如果当前字符匹配成功，即S[i]==T[j]，令i++，j++，继续匹配下一个字符；如果匹配失败，即S[i] != T[j]，需要保持i不变，并且让j = next[j]，这里next[j] <=j -1，即模式串T相对于原始串S向右移动了至少1位(移动的实际位数j - next[j] >=1)。同时移动之后，i之前的部分（即S[i-j+1 ~ i-1]），和j=next[j]之前的部分（即T[0 ~ j-2]）仍然相等。（这里j-1就是T[j]在KMP中所谓的特征向量值）显然，相对于BF算法来说，KMP移动更多的位数，起到了一个加速的作用！ (失配的特殊情形，令j=next[j]导致j==0的时候，需要将i ++，否则此时没有移动模式串)。

要是按照普通字符串匹配BF算法，字符串的匹配是按照S串逐个进行匹配的，每次的回溯都是strlen(T)-1，这注定了时间效率的低下。

能不能不进行回溯，直接跳到S串不匹配的字符处？显然是不行的。

如模式串中包含重复出现的字符，比如ababc。当和abababc进行匹配时：

abababc

ababc

匹配到c时如果不进行回溯的话：

abababc

ababc

将找不到匹配的字符

但是也有特殊的情形如abcde和ababcde进行匹配，在模式串中没有重复出现的字符。那么可以不进行回溯。

ababcde

abcde

ababcde

abcde

显然可以看出回溯的原因是因为模式串中有重复出现的字符，如果不回溯可能会跳过匹配的字符串。用比较专业的说法是模式串中所有字符串的“前缀”和“后缀”的相等部分的长度不为0。模式串长度为n，则存在n个字符串的“前缀”和“后缀”。

什么叫做“前缀”和“后缀”，非专业人士的认识如下：

例如：

设模式串T0,T1,T2,T3,T4为ababc

则ababc中aba字符串的前缀和后缀相同的部分为T0和T2，长度为1.

ababc中abab字符串的前缀和后缀相同的部分为T0T1和T2T3，长度为2.

如果模式串T0,T1,T2,T3,T4为abcde

则abcde中所有字符串的前缀和后缀相同的部分长度为0.如：a，ab，abc，abcd，abcde

注意：只要模式串中的某个字符串的前缀和后缀有相同的部分，则这个模式字符串匹配时将需要进行回溯。

KMP 算法思想
普通的字符串匹配算法必须要回溯。但回溯就影响了效率，回溯是由T串本身的性质决定的，是因为T串本身有前后'部分匹配'的性质。像上面所说如果T串为abcde这样的，大没有回溯的必要。

改进的地方也就是这里，我们从T串本身出发，事先就找准了T自身前后部分匹配的位置，那就可以改进算法。

如果不用回溯，那模式串下一个位置从哪里开始呢？

还是上面那个例子，T(模式串)为ababc，如果c失配，那就可以往前移到aba最后一个a的位置，像这样：

...ababd...

ababc

->ababc

这样i不用回溯，j跳到前2个位置，继续匹配的过程，这就是KMP算法所在。这个当T[j]失配后，j 应该往前跳的值就是j的next值，它是由T串本身固有决定的，与S串(主串)无关。

next数组的含义

重点来了。下面解释一下next数组的含义，这个也是KMP算法中比较不好理解的一点。

令原始串为: S[i]，其中0<=i<=n；模式串为: T[j]，其中0<=j<=m。

假设目前匹配到如下位置

S0,S1,S2,...,Si-j,Si-j+1...............,Si-1, Si, Si+1,....,Sn

T0,T1,...................,Tj-1, Tj, ..........

S和T的绿色部分匹配成功，恰好到Si和Tj的时候失配，如果要保持i不变，同时达到让模式串T相对于原始串S右移的话，可以更新j的值，让Si和新的Tj进行匹配，假设新的j用next[j]表示，即让Si和next[j]匹配，显然新的j值要小于之前的j值，模式串才会是右移的效果，也就是说应该有next[j] <= j -1。那新的j值也就是next[j]应该是多少呢？我们观察如下的匹配：

1)如果模式串右移1位（从简单的思考起，移动一位会怎么样），即next[j] = j - 1，即让蓝色的Si和Tj-1匹配 (注：省略号为未匹配部分)

S0,S1,S2,...,Si-j,Si-j+1...............,Si-1, Si, Si+1,....,Sn

T0,T1,...................,Tj-1, Tj, .......... (T的划线部分和S划线部分相等【1】)

T0,T1,................Tj-2,Tj-1, ....... (移动后的T的划线部分和S的划线部分相等【2】)

根据【1】【2】可以知道当next[j] =j -1，即模式串右移一位的时候，有T[0 ~ j-2] == T[1 ~ j-1]。而这两部分恰好是字符串T[0 ~j-1]的前缀和后缀，也就是说next[j]的值取决于模式串T中j前面部分的前缀和后缀相等部分的长度（好好揣摩这两个关键字概念：前缀、后缀，或者再想想，我的上一篇文章，从Trie树谈到后缀树中，后缀树的概念）。

2)如果模式串右移2位，即next[j] = j - 2，即让蓝色的Si和Tj-2匹配

S0,S1,...,Si-j,Si-j+1,Si-j+2...............,Si-1, Si, Si+1,....,Sn

T0,T1,T2,...................,Tj-1, Tj, ..........(T的划线部分和S划线部分相等【3】)

T0,T1,.............,Tj-3,Tj-2,.........(移动后的T的划线部分和S的划线部分相等【4】)

同样根据【3】【4】可以知道当next[j] =j -2，即模式串右移两位的时候，有T[0 ~ j-3] == T[2 ~ j-1]。而这两部分也恰好是字符串T[0 ~j-1]的前缀和后缀，也就是说next[j]的值取决于模式串T中j前面部分的前缀和后缀相等部分的长度。

3)依次类推，可以得到如下结论：当发生失配的情况下，j的新值next[j]取决于模式串中T[0 ~ j-1]中前缀和后缀相等部分的长度，并且next[j]恰好等于这个最大长度。

为此，请再允许我引用上文中的一段原文：“KMP算法中，如果当前字符匹配成功，即S[i]==T[j]，令i++，j++，继续匹配下一个字符；如果匹配失败，即S[i] != T[j]，需要保持i不变，并且让j = next[j]，这里next[j] <=j -1，即模式串T相对于原始串S向右移动了至少1位(移动的实际位数j - next[j] >=1),

同时移动之后，i之前的部分（即S[i-j+1 ~ i-1]），和j=next[j]之前的部分（即T[0 ~ j-2]）仍然相等。显然，相对于BF算法来说，KMP移动更多的位数，起到了一个加速的作用！ (失配的特殊情形，令j=next[j]导致j==0的时候，需要将i ++，否则此时没有移动模式串)。”

next数组求法

可以证明对于任意的模式串T=T0T1…Tm-1,确实存在一个由模式串本身唯一确定的与目标串无关的数组next，计算方法为：
(1) 令next[0] ＝ -1，令next[1] = 0;对于i > 1的next[i] ，假定已知前一位置的特征数 next[i-1]＝k；
(2) 当k≠-1且Ti-1 ＝ Tk ，则next[i] ＝k + 1 ;

(3) 当k≠-1且Ti-1 ≠ Tk，则令 k ＝ next [k];
(4) 当k==-1 next[i] = 0。

(非优化的)

简单举例说明下计算方法：

还是上面的例子设模式串T0,T1,T2,T3,T4为ababc

当i=0，next[0]=-1

当i=1，next[1]=0;

当i=2，(1)next[1]=0, => k=0 (3) T1=b≠ T0=a k=next[0]=-1 (4) next[2]=0;

当 i=3，(1)next[2]=0, =>k=0 (2)T2=a, T0=a T2=T0 则next[3]=k+1=1;

当 i=4，(1)next[3]=1,=>k=1 (2)T3=b,T1=b T3=T0 则 next[4]=k+1=2;

void get_next(string s,int next[])
{    
    int length=s.length();
    int i=0,j=-1;
    next[0]=-1;
    while(i<length)
    {
        if(j==-1||s[i]==s[j])  
        {
            ++i;
            ++j;   
            next[i]=j;
        }
        else
            j=next[j];  
     }
}

//代码5-1    
//int kmp_seach(char const*, int, char const*, int, int const*, int pos)  KMP模式匹配函数    
//输入：src, slen主串    
//输入：patn, plen模式串    
//输入：nextval KMP算法中的next函数值数组    
int kmp_search(char const* src, int slen, char const* patn, int plen, int const* nextval, int pos)    
{    
    int i = pos;    
    int j = 0;    
    while ( i < slen && j < plen )    
    {    
        if( j == -1 || src[i] == patn[j] )    
        {    
            ++i;    
            ++j;    
        }    
        else    
        {    
            j = nextval[j];              
            //当匹配失败的时候直接用p[j_next]与s[i]比较，    
            //下面阐述怎么求这个值，即匹配失效后下一次匹配的位置    
        }    
    }    
    if( j >= plen )    
        return i-plen;    
    else    
        return -1;    
}

参考：

http://blog.csdn.net/liuben/article/details/4409505

http://blog.csdn.net/v_july_v/article/details/7041827