字符串匹配的KMP算法---理解next数组的意义

本文是查阅多篇文章进行整理，目的是直白清晰的讲解KMP的主要思路。

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

                               http://blog.csdn.net/yearn520/article/details/6729426

                             算法导论





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

举例来说，有一个字符串"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算法的原理有个清晰的了解，那么下一步就是编程实现了，其中最重要的就是如何根据待匹配的模版字符串求出对应每一位的最大相同前后缀的长度。我先给出我的代码：

void makeNext(string p, vector<int>& next)
{
next[0] = 0;
for (int q = 1, k = 0; q < p.size(); ++q)
{
while (k > 0 && p[q] != p[k])
k = next[k - 1];
if (p[q] == p[k])
k++;
next[q] = k;
}
}

在这里我举个例子：   

假设我们的模式字符串如下，注意我加的括号只是用来说明问题，并不在字符串内部：

p = " (a g c t a g c )( a g c t a g c) t"

我们可以看到这段，p[14] (也就是最后的t) 之前的两个括号里面是匹配的，这时候next[13] = 7。如果继续找的话，会比较next[14] 和 next[7]，得到'a'!='t'，这个时候next[14]的部分匹配值就要重新来求。

这里首要要申明几个事实：
          1、"部分匹配值"就是"前缀"和"后缀"的最长的共有元素的长度。前缀一定从字符串首元素开始，同理后缀一定包括字符串尾元素。

2、这时候不能继续匹配，也就是说前面匹配的7个元素没法用了，这时候怎么办？注意这个next[14]不能单纯置为0，而是应该找找这7个元素的字符串是不是存在部分匹配值！

如下图说明。



 我们肉眼观察下，其实我们可以找到部分匹配值为子串"agct"，得到next[14] = 4。



这个"agct"如何得到呢。

1.首先，我们找“agctagc" 这个长匹配的部分匹配值。具体过程为先找
t 前一位的匹配长度，k = next[14-1] = 7,  也就是“agctagc"这个匹配串。

2.然后我们找找这k个元素，也就是agctagc"这个匹配串是不是自身存在"部分匹配值"，发现k
= next[7-1] = 3，得到"agc"子串，他是“agctagc"的部分匹配值。

3.接着比较下一位，就是next[3] 和 next[14]，发现匹配，这时候k++，也就是找到“agct"了。

4.为什么能这么找呢，因为前前面7+7个字符串一模一样呀！细细体味下吧，该说的我说完了，给你5分钟体会下这个过程……

看懂了我就上完整代码了：

void makeNext(string p, vector<int>& next)
{
next[0] = 0;
for (int q = 1, k = 0; q < p.size(); ++q)
{
while (k > 0 && p[q] != p[k])
k = next[k - 1];
if (p[q] == p[k])
k++;
next[q] = k;
}
}

int kmp(string s, string p)
{
vector<int> next(p.size());
makeNext(p, next);
for (int i = 0, q = 0; i < s.size(); ++i)
{
while (q > 0 && p[q] != s[i])
q = next[q - 1];
if (p[q] == s[i])
q++;
if (q == p.size())
return i - p.size() + 1;
}
return -1;
}

int _tmain(int argc, _TCHAR* argv[])
{
string s = "agctagcagctagccagctagcagctagct";
string p = "agctagcagctagct";
cout << kmp(s, p) << endl;
return 0;
}