KMP算法总结

真想说一句“日了KMP”

本帖以几乎是转载的，加了一点自己的理解。

 

网上已经有了各种对KMP算法的讲解，有的易懂，有的复杂，我觉得下面这篇就不错

http://www.cnblogs.com/c-cloud/p/3224788.html

前言　　

　　之前对kmp算法虽然了解它的原理，即求出P₀···P_i的最大相同前后缀长度k；但是问题在于如何求出这个最大前后缀长度呢？我觉得网上很多帖子都说的不是很清楚，总感觉没有把那层纸戳破，后来翻看算法导论，32章 字符串匹配虽然讲到了对前后缀计算的正确性，但是大量的推理证明不大好理解，没有与程序结合起来讲。今天我在这里讲一讲我的一些理解，希望大家多多指教，如果有不清楚的或错误的请给我留言。　

1.kmp算法的原理：

　　本部分内容转自：http://www.ruanyifeng.com/blog/2013/05/Knuth%E2%80%93Morris%E2%80%93Pratt_algorithm.html

　　

字符串匹配是计算机的基本任务之一。

举例来说，有一个字符串"BBC ABCDAB ABCDABCDABDE"，我想知道，里面是否包含另一个字符串"ABCDABD"？

许多算法可以完成这个任务，Knuth-Morris-Pratt算法（简称KMP）是最常用的之一。它以三个发明者命名，起头的那个K就是著名科学家Donald Knuth。

这种算法不太容易理解，网上有很多解释，但读起来都很费劲。直到读到Jake Boxer的文章，我才真正理解这种算法。下面，我用自己的语言，试图写一篇比较好懂的KMP算法解释。

1.

首先，字符串"BBC ABCDAB ABCDABCDABDE"的第一个字符与搜索词"ABCDABD"的第一个字符，进行比较。因为B与A不匹配，所以搜索词后移一位。

2.

因为B与A不匹配，搜索词再往后移。

3.

就这样，直到字符串有一个字符，与搜索词的第一个字符相同为止。

4.

接着比较字符串和搜索词的下一个字符，还是相同。

5.

直到字符串有一个字符，与搜索词对应的字符不相同为止。

6.

这时，最自然的反应是，将搜索词整个后移一位，再从头逐个比较。这样做虽然可行，但是效率很差，因为你要把"搜索位置"移到已经比较过的位置，重比一遍。

7.

一个基本事实是，当空格与D不匹配时，你其实知道前面六个字符是"ABCDAB"。KMP算法的想法是，设法利用这个已知信息，不要把"搜索位置"移回已经比较过的位置，继续把它向后移，这样就提高了效率。

8.

怎么做到这一点呢？可以针对搜索词，算出一张《部分匹配表》（Partial Match Table）。这张表是如何产生的，后面再介绍，这里只要会用就可以了。

9.

已知空格与D不匹配时，前面六个字符"ABCDAB"是匹配的。查表可知，最后一个匹配字符B对应的"部分匹配值"为2，因此按照下面的公式算出向后移动的位数：

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

因为 6 - 2 等于4，所以将搜索词向后移动4位。

10.

因为空格与Ｃ不匹配，搜索词还要继续往后移。这时，已匹配的字符数为2（"AB"），对应的"部分匹配值"为0。所以，移动位数 = 2 - 0，结果为 2，于是将搜索词向后移2位。

11.

因为空格与A不匹配，继续后移一位。

12.

逐位比较，直到发现C与D不匹配。于是，移动位数 = 6 - 2，继续将搜索词向后移动4位。

13.

逐位比较，直到搜索词的最后一位，发现完全匹配，于是搜索完成。如果还要继续搜索（即找出全部匹配），移动位数 = 7 - 0，再将搜索词向后移动7位，这里就不再重复了。

14.

下面介绍《部分匹配表》是如何产生的。

首先，要了解两个概念："前缀"和"后缀"。 "前缀"指除了最后一个字符以外，一个字符串的全部头部组合；"后缀"指除了第一个字符以外，一个字符串的全部尾部组合。

15.

"部分匹配值"就是"前缀"和"后缀"的最长的共有元素的长度。以"ABCDABD"为例，

　　－　"A"的前缀和后缀都为空集，共有元素的长度为0；

　　－　"AB"的前缀为[A]，后缀为[B]，共有元素的长度为0；

　　－　"ABC"的前缀为[A, AB]，后缀为[BC, C]，共有元素的长度0；

　　－　"ABCD"的前缀为[A, AB, ABC]，后缀为[BCD, CD, D]，共有元素的长度为0；

　　－　"ABCDA"的前缀为[A, AB, ABC, ABCD]，后缀为[BCDA, CDA, DA, A]，共有元素为"A"，长度为1；

　　－　"ABCDAB"的前缀为[A, AB, ABC, ABCD, ABCDA]，后缀为[BCDAB, CDAB, DAB, AB, B]，共有元素为"AB"，长度为2；

　　－　"ABCDABD"的前缀为[A, AB, ABC, ABCD, ABCDA, ABCDAB]，后缀为[BCDABD, CDABD, DABD, ABD, BD, D]，共有元素的长度为0。

16.

"部分匹配"的实质是，有时候，字符串头部和尾部会有重复。比如，"ABCDAB"之中有两个"AB"，那么它的"部分匹配值"就是2（"AB"的长度）。搜索词移动的时候，第一个"AB"向后移动4位（字符串长度-部分匹配值），就可以来到第二个"AB"的位置。

2.next数组的求解思路

　　通过上文完全可以对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])//如果相等，那么最大相同前后缀长度加111         {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 }

 

3.kmp的优化

待续。。。。

我的理解

KMP之所以能取得O(m+n)的线性时间复杂度，原因就是来源于他灵活的跳转，利用已经匹配过的字符直接跳过肯定不匹配的字符串，而这主要决定于next数组

 

这也一直都是我所认为的那句话，算法不过是两点

少做无用功，

更有效率的来做有用功

 

Next数组必须要保证两点，

1、 尽可能的提高效率

2、 不能错过任何可能的匹配

 

如何求解next数组及如何高效的求解next数组便成了首要问题。

Next数组有两个很重要的概念，【前缀数组】、【后缀数组】

前缀数组应该是以字符串首字母为固定起始字母，结束字符最多为指定位置前一个字符的顺序字符串组合

后缀数组则是以指定位置前一个字符为固定结束字符，起始字符最前延伸到首字符的顺序字符串组合。

 

好像说的还是有点绕口。

对于字符串 abcabdefgh

假设指定字符位置为d，那么前一个字符为b

于是前缀数组有 

a

ab

abc

abca

abcab

后缀数组有

b

ab

cab

bcab

abcab

Next 数组则是找到前缀数组和后缀数组中相同字符数目最大的那一个，当然了，注意这里不包含abcabd，因为两者已经重合了。

 

如上图中不算上abcab串，那么应该是ab是最大的了，因此字符d所对应的next值应该是2

 

为什么next数组值，可以让数组跳转到正确的位置？

以上表为例，假设在匹配到‘d’字符时不匹配，查找next数组，发现‘d’字符对应的值为2，也就是匹配字符串在‘d’之前有长度为2的前缀数组和后缀数组是相同的。而匹配到‘d’的时候，之前的字符都是匹配的，因此可以利用这些信息，直接让前缀数组对其当前后缀数组的位置，并且前缀数组不需要匹配，直接从前缀数组的后一个字符开始匹配，也就是‘c’。效率就在这里体现出来。

 

 

如何求得next数组值

其实看代码就知道，计算next数组的代码和匹配的代码几乎一样。很好理解啊，匹配之间的代码不过是和别人的匹配，计算next数组不过是和自己匹配罢了。

 

当然了最暴力的方法肯定是先找出所有的前缀后缀数组然后从大到小一一匹配，如果相同就是它了。

 

但是聪明的程序员怎么可能容忍如此低效的计算。很明显后面的字符依赖于前面的字符，因为如果前面的串都不匹配，后面的串更加不可能匹配了。

比如 abcabdefgh

第一个字符 ‘a’ ，前面都没有字符，没什么好比的

第二个字符 ‘b’ ，前面就一个字符，没什么好比的

第三个字符 ‘c’ ，前面是a b,前缀 ‘a’,后缀’b’，不同

 

第四个字符 ‘a’ ，前缀 ‘a’, ‘ab’，后缀’c’， ’bc’,不同

第五个字符 ‘b’ ，前缀 ‘a’, ‘ab’，‘abc’,后缀’a’， ’ca’,’bca’, ‘a’相同

第六个字符 ‘d’ ，前面有了一个‘a’相同，这次直接比较‘a’后面的一个字符‘b’，也就是前缀‘ab’,后缀‘ab’，相同因此直接为2。

这里有几种情况，如果相同，很简单，前面的字符有一个相同前缀，后面的字符最多也就是2个。 如果不同在判断。

第七个字符 ‘e’ ，前面有了一个‘ab’相同，这次直接比较‘ab’后面的一个字符‘c’，也就是前缀‘abc’,后缀‘abd’，不相同了，在这里直接就为0了，因为有了一个坏字符，‘d’在之前从来没有出现过。否则需要如下式计算

j = next[j];

后面的就以此类推了。

 

 

还有一个更容易理解，跟简单，效率更高的算法

Sunday算法