KMP算法

转载自：http://blog.csdn.net/hyjoker/article/details/51190726和http://www.cnblogs.com/c-cloud/p/3224788.html

暴力匹配算法

    暴力匹配的思路，假设现在文本串S匹配到 i 位置，模式串P匹配到 j 位置，则有：

• 如果当前字符匹配成功（即S[i] == P[j]），则i++，j++，继续匹配下一个字符；
• 如果失配（即S[i]! = P[j]），令i = i - (j - 1)，j = 0。相当于每次匹配失败时，i 回溯，j 被置为0。

KMP算法概述

KMP算法用于字符串匹配问题，核心思想是找到子串中的重复出现的连续字符并将其记录到数组中。通过这种方式减少失配后回溯长度，以减少匹配次数。

KMP算法其实是基于暴力匹配，并加上next数组之后的成果。

通俗易懂的解释见：点击打开链接（这是理解后面内容的基础）

KMP算法过程

假设现在文本串S匹配到 i 位置，模式串P匹配到 j 位置，则有：

• 如果当前字符匹配成功（即S[i] == P[j]），则i++，j++，继续匹配下一个字符；
• 如果失配（即S[i]! = P[j]），令i = i - (j - 1)，j = 0。相当于每次匹配失败时，j回溯到next[j]

可以发现：KMP算法和暴力匹配算法（BF算法）区别在于KMP算法中i不需要回溯且j回溯到next[j]的位置。

看过上面blog中通俗的解释之后，我们大概理解了KMP算法的核心思想，大概也能写出部分匹配值表。现在我们来搞懂next数组和部分匹配值表的关系。（此处搬来那篇博文中的这个表）

我们所用的移位公式为：

移动位数 = 已匹配的字符数 - 对应的部分匹配值

所以j每次回溯的移动位数就是已经匹配的字符数-对应匹配值， 因为对于同一个字符串来

说， 每个字符的这些相关信息 是固定的， 我现在只需要 把这个信息放在一个数组里，每次

需要移动 时候就直接让 j等于对应位置的移动位数信息,这不就轻松加愉快了。 由于每次都

通过这个数组j 可以 移动到它需要去的下一个位置，所以我们不妨将其称为next组，每次执

行的过程就是是j=next[j]

那我们现在就要考虑如何构建next数组。

那么问题就来了，我们移动的位数（即下次j将要去的地方）和当前的字符匹配值并没有什么

卵关系， 它只在乎已经匹 配了的那个字符相关的信 息。 既然它不在乎我，那我还管它干嘛，

那么我们所需要的 当前移动位数就和当前字符没啥关系了，是时候say goodbye了。

但是虽然说当前匹配值和当前移动位数已经没什么关系了，它却影响了下一个位置的移动

位数，所以我们要将它和下 一个位置关联起来。 如此一来，每个当前位置的移动位数都与

前面的匹配值相关，而下一个位置的移动位数又与当前 匹配值相关……我们自然而然就明白了

，我只要 将table表中的部分匹配值都右移一位，就可以得到next表了。

那么现在给我们一个字符串，我们就可以自己推出它的next数组了。基本工作已经完成了一

半，现在我们的任务就是 通过代码的方式写出求 next数组的基本方法：

基于之前的理解，我们可以明白next数组是可以通过递推求出的：

1.如果对于值k，已有p0 p1, ..., pk-1 = pj-k pj-k+1, ..., pj-1，相当于next[j] = k。

即字符串开始的k-1个和当前位置j之前的k-1个对应相等，那么j下一次回溯的位置就是这个k

（因为前面部分都一致，再进行一遍就是无效回溯了）

2.根据已知的next[0...j]求next[j+1]

1）首先，若p[k]==p[j]，则next[j+1]=next[j]+1=k+1;

这个很好理解，就是只要相同就+1就行了。比如下图中C和C相等，所以next[j+1]=2+1=3;

2）若p[k]!=p[j]，k索引next[k]直到与p[j]相等，此时可用公式next[j+1]=k+1（不能用

next[j+1]=next[j]+1，因为此时k已经变了，所以 next[j]已经和k不相等 了） ，若没有，则为0

理解起来就是：如果当前的字符不匹配，那么需要寻找长度更短的前缀后缀，让j回溯到

相应的位置（如下图）

为何递归前缀索引k = next[k]，就能找到长度更短的相同前缀后缀呢？

这又归根到next数组的含义。我们拿前缀 p0 pk-1 pk 去跟后缀 pj-k pj-1 pj匹配，

如果pk 跟pj 失配，下一步就是用p[next[k]] 去跟pj 继续匹配， 如果 p[ next[k] ]跟pj 还是 不匹配， 则需要寻找 长度更短的相同前缀后缀，即下一步用p[ next[ next[k] ] ]去跟pj匹 配 。此过程相当于模式串的自我匹配， 所以不断的递归k = next[k]， 直到要么找到长度更短 的 相同前缀后缀，要么没有长度更短的相同前缀后缀。如下图所示： 

现在我们来测试下k回溯是不是可以找到之前相同前后缀：

由于此时的C和D不匹配，所以k走到next[k]即k=0,此时p[0]=p[j]，所以next[j]=k+1=1。即字符E之前的字符串“DABCDABD”中有长度为1的相同前缀和后缀

通过上文完全可以对kmp算法的原理有个清晰的了解，那么下一步就是编程实现了，其中最重要的就是如何根据待匹配的模版字符串求出对应每一位的最大相同前后缀的长度。我先给出我的代码：

 1 void makeNext(const char P[],int next[])
 2 {
 3     int q,k;//q:模版字符串下标；k:最大前后缀长度
 4     int m = strlen(P);//模版字符串长度
 5     next[0] = 0;//模版字符串的第一个字符的最大前后缀长度为0
 6     for (q = 1,k = 0; q < m; ++q)//for循环，从第二个字符开始，依次计算每一个字符对应的next值
 7     {
 8         while(k > 0 && P[q] != P[k])//递归的求出P[0]···P[q]的最大的相同的前后缀长度k
 9             k = next[k-1];          //不理解没关系看下面的分析，这个while循环是整段代码的精髓所在，确实不好理解  
10         if (P[q] == P[k])//如果相等，那么最大相同前后缀长度加1
11         {
12             k++;
13         }
14         next[q] = k;
15     }
16 } 

 　　现在我着重讲解一下while循环所做的工作：

1. 　　已知前一步计算时最大相同的前后缀长度为k（k>0），即P[0]···P[k-1]；
2. 　　此时比较第k项P[k]与P[q],如图1所示
3. 　　如果P[K]等于P[q]，那么很简单跳出while循环;
4. 　　关键！关键有木有！关键如果不等呢？？？那么我们应该利用已经得到的next[0]···next[k-1]来求P[0]···P[k-1]这个子串中最大相同前后缀，可能有同学要问了——为什么要求P[0]···P[k-1]的最大相同前后缀呢？？？是啊！为什么呢？ 原因在于P[k]已经和P[q]失配了，而且P[q-k] ··· P[q-1]又与P[0] ···P[k-1]相同，看来P[0]···P[k-1]这么长的子串是用不了了，那么我要找个同样也是P[0]打头、P[k-1]结尾的子串即P[0]···P[j-1](j==next[k-1])，看看它的下一项P[j]是否能和P[q]匹配。如图2所示

 

 

附代码：

 1 #include<stdio.h>
 2 #include<string.h>
 3 void makeNext(const char P[],int next[])
 4 {
 5     int q,k;
 6     int m = strlen(P);
 7     next[0] = 0;
 8     for (q = 1,k = 0; q < m; ++q)
 9     {
10         while(k > 0 && P[q] != P[k])
11             k = next[k-1];
12         if (P[q] == P[k])
13         {
14             k++;
15         }
16         next[q] = k;
17     }
18 }
19 
20 int kmp(const char T[],const char P[],int next[])
21 {
22     int n,m;
23     int i,q;
24     n = strlen(T);
25     m = strlen(P);
26     makeNext(P,next);
27     for (i = 0,q = 0; i < n; ++i)
28     {
29         while(q > 0 && P[q] != T[i])
30             q = next[q-1];
31         if (P[q] == T[i])
32         {
33             q++;
34         }
35         if (q == m)
36         {
37             printf("Pattern occurs with shift:%d\n",(i-m+1));
38         }
39     }    
40 }
41 
42 int main()
43 {
44     int i;
45     int next[20]={0};
46     char T[] = "ababxbababcadfdsss";
47     char P[] = "abcdabd";
48     printf("%s\n",T);
49     printf("%s\n",P );
50     // makeNext(P,next);
51     kmp(T,P,next);
52     for (i = 0; i < strlen(P); ++i)
53     {
54         printf("%d ",next[i]);
55     }
56     printf("\n");
57 
58     return 0;
59 }