KMP算法详解及C++实现

**

一.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********《部分匹配表》

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

“部分匹配值”就是”前缀”和”后缀”的最长的共有元素的长度。以”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。

15***************

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

**

二、next数组的求解思路

**
KMP算法的特点：

• 一次右移多个字符
• 避免已匹配的字符串重复比对

KMP算法是如何做到这两点的呢？KMP提前构造了一张查询表。美妙的是查询表的构建与文本串无关，使得我们可以根据模式串提前构造查询表，KMP也因此具有了预知功能，这是KMP能够提高效率的关键。

为什么next表的构建与文本串无关呢？如下图所示，在P[j]之前模式串与文本串完全相等（长度记作partial_match_length），因此，我们可以只考虑模式串。再进一步，前缀是由P[j]决定的，只需对每一个j构建next表（查询表），而j的取值范围不过是[0,M)。

j为模式串的索引，j == partial_match_length（例：j=3时考虑的是模式串中的前3个字符P[0,3)）。以next[j] == 3为例,一次向右滑动partial_match_length - 3个位置，也就是说将P[next[j]]处的字符移动到P[j],即P[j] = P[next[j]],这一操作实现了一次右移多个字符。又因为相对于P[j]的前缀，其首部和尾部具有一定的相似性,已知P[0,next[j])与P[j-next[j],j)完全匹配，即可从P[j]处重新开始比对。
令最大自匹配的真前缀和真后缀的长度为t; KMP算法能够快速滑过j-2t个字符，避免重复比对t个字符。

综上，模式串与文本串在某一位置匹配失败后，KMP算法能告诉我们应该将模式串中的哪个字符移动到比对失败处，并且从失败处重新开始比对。

既然next表决定了KMP算法的走向，那么next表应该如何构建呢？表中的每一项又有什么具体含义呢？

next[j]代表什么？next[j]的值是模式串中长度为partial_match_length的子字符串真前缀与真后缀完全匹配的最大长度。模式串中partial_match_length为0的子串（首字符的前缀），首字符的前缀为空，令next[0]=-1;

j=6，即partial_match_length=6，对应的子字符串为：ababab所有真前缀为：a,ab,aba,abab,ababa；所有真后缀为：babab,abab,bab,ab,b.可得真前缀与真后缀完全匹配的最大长度为4(abab)，所以next[6]=4.

这里使用了一个小技巧：在模式串的左端设置一个哨兵，索引为-1，字符是一个通配符，能够匹配所有的字符。这样做的好处有两个：保持算法逻辑上的统一；使算法更加简洁。

在计算next[j+1]时，当P[j]不等于P[next[j]]以及后续许多P[next of next of next of … next[j]]，最后收敛于1+next[0]，若next[0] == 0，P[next[0]] == P[0] != P[j]，需要单独对这种情况进行处理，算法的逻辑和实现都更加复杂。

以计算nextj+1:
P[6] == c != P[next[6]] == a, 计算P[next[next[6]]] == P[2] == a != c，计算P[next[next[next[6]]]] == P[0] == a != c，接着计算P[next[next[next[next[6]]]]] == P[-1] == c 推出next[7] = 1 + next[0],即next[7]=0;
观察这个计算过程， P[0] == a != c如果不设置哨兵，这种情况该怎么处理呢？（体会一下设置少哨兵的妙处）

知道了next表的含义，接下来就该从代码的角度构建next表了：已知next[0,j],计算next[j+1],当P[j] == P[next[j]]，next[j+1] = next[j] + 1；当P[j] != P[next[j]]，依次比对P[j]与P[next[next[j]]]…最坏的情况收敛于P[j] == P [next[0]],此时next[j+1] = 1 + next[0];
next表的构建代码如下：

public static int buildNext(String pat) {        int M = pat.length();        int j = 0;        int[] next = new int[M];        next[0] = -1;        while (j < M -1) {            if (0 > next[j] || pat.charAt(j) == pat.charAt(next[j])) {                next[++j] = ++next[j];            } else {                next[j] = next[next[j]];            }        }        return M;}

KMP算法很聪明，那么它是完美的吗？至少现在我们的KMP算法还有改进的空间。看下面一种情况：

当P[j] != T[I + j]时,用P[next[j]]替换P[j]，观察上图可知多了三次不必要的比对，能不能避免这种情况呢？问题出在了哪里呢？

用来替换P[j]的P[next[j]]和P[j]相等，匹配会继续失败。

对于匹配失败处的字符，KMP能告诉我们它应该是什么，如果它也能告诉我们不应该是什么，那么上面例子中的三次不必要的比对就可以避免。

改进后的KMP算法如下:

public static int buildNextElevate(String pat) {        int M = pat.length();        int j = 0;        int[] next = new int[M];        next[0] = -1;        while (j < M -1) {            if (0 > next[j] || pat.charAt(j) == pat.charAt(next[j])) {                j++; next[j]++;                next[j] = pat.charAt(j) != pat.charAt(next[j]) ? next[j] : next[next[j]];//与前一版本的不同之处            } else {                next[j] = next[next[j]];            }        }        return M;}