KMP算法详解

前言

前几天，突然听到一位刚刚面试完应聘者的同事吐槽到“现在的程序员基本功怎么这么差，连一个简单的KMP算法都搞不定，还好意思开那么高的薪水"。听到这里，笔者默默的翻出《数据结构》，打开google。本文正是在这样的背景下对KMP算法的复习与整理。

简介

该算法是一种改进的字符串匹配算法，由D.E.Knuth与V.R.Pratt和J.H.Morris同时发现，因此称之为KMP算法。此算法可以在O(n+m)的时间数量级上完成串的模式匹配操作。

思想

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

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

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

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

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

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

这时，最自然地方式就是将搜索字符串整个后移一位，再从头逐个比较。这样做虽然可行，但是效率很差，因为你要把"搜索位置"移到已经比较过的位置，重比一遍。其算法时间复杂度即为O(m*n)。

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

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

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

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

6-2=4，则将搜索字符串后移4位。

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

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

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

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

部分匹配表的生成

从上面的匹配过程，我们发现部分匹配表是KMP算法的关键所在，解下来让我们看一下部分匹配表是如何生成的。

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

字符串“string”为例，则“string”的前缀即为: “s", "st", "str", "stri", "strin"。其后缀即为： "g", "ng", "ing", "ring", "tring"。

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

字符串	前缀	后缀	部分匹配值
A	空集	空集	0
AB	A	B	0
ABC	A, AB	C, BC	0
ABCD	A, AB, ABC	D, CD, BCD	0
ABCDA	A, AB, ABC, ABCD	A, DA, CDA, BCDA,	1
ABCDAB	A, AB, ABC, ABCD, ABCDA	B, AB, DAB, CDAB, BCDAB	2
ABCDABD	A, AB, ABC, ABCD, ABCDA, ABCDAB	D, BD, ABD, DABD, CDABD, BCDABD	0

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

实现

在KMP算法中有个数组，叫做前缀数组，也有的叫next数组，每一个子串有一个固定的next数组，它记录着字符串匹配过程中失配情况下可以向前多跳几个字符，当然它描述的也是子串的对称程度，程度越高，值越大，当然之前可能出现再匹配的机会就更大。next数组的求法是KMP算法的关键，但是理解next数组并不是一件轻松的事情。

由上文，我们已经知道，字符串“ABCDABD”各个前缀后缀的最大公共元素长度分别为：

而且，根据这个表可以得出下述结论

失配时，模式串向右移动的位数为：已匹配字符数 - 失配字符的上一位字符所对应的最大长度值

上文利用这个表和结论进行匹配时，我们发现，当匹配到一个字符失配时，其实没必要考虑当前失配的字符，更何况我们每次失配时，都是看的失配字符的上一位字符对应的最大长度值。如此，便引出了next 数组。

给定字符串“ABCDABD”，可求得它的next 数组如下：

把next 数组跟之前求得的最大长度表对比后，不难发现，next 数组相当于“最大长度值” 整体向右移动一位，然后初始值赋为-1。意识到了这一点，你会惊呼原来next 数组的求解竟然如此简单！

换言之，对于给定的模式串：ABCDABD，它的最大长度表及next 数组分别如下：

根据最大长度表求出了next 数组后，从而有

右移位数 = 失配字符所在位置 - 失配字符对应的next 值

而后，你会发现，无论是基于《最大长度表》的匹配，还是基于next 数组的匹配，两者得出来的向右移动的位数是一样的。

接下来，咱们来写代码求下next 数组。

基于之前的理解，可知计算next函数的方法可以采用递推，如果对于值k，有p0 p1, ..., pk-1 = pj-k pj-k+1, ..., pj-1，相当于next[j-1] = k。那么对于pattern的前j 个序列字符，得

若pattern[k] == pattern[j]，则next[j] = next(j-1) + 1 = k + 1
若pattern[k ] ≠ pattern[j]，相当于在字符p[k]之前不存在前缀"p0 p1, …, pk-1"跟后缀“pj-k pj-k+1, …, pj-1"相等，那么是否可能存在另一个值t<k，使得p0 p1, …, pk-1 = pj-t pj-t+1…pj-1成立呢？这个t 显然应该是next[k]，因为这相当于一个"利用next函数值进行T串和T串的匹配"问题。

求next数组如下：

 1 void getNext(const char *pattern, int *next, int pattern_len)
 2 {
 3     int i = 0;
 4     int j = -1;
 5     next[0] = -1;
 6 
 7     while (i < pattern_len - 1)
 8     {
 9 
10         if (j == -1 || pattern[i] == pattern[j])
11         {
12             ++i;
13             ++j;
14             if (pattern[i] != pattern[j]) //正常情况
15                 next[i] = j;
16             else //特殊情况，这里即为优化之处。考虑下AAAAB, 防止4个A形成012在匹配时多次迭代。
17                 next[i] = next[j];
18         }
19         else
20         {
21             j = next[j];
22         }
23 }

完整代码如下：

 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 #include <string.h>
 4 
 5 
 6 static inline void getNext(const char *pattern, int *next, int pattern_len)
 7 {
 8     int i = 0;
 9     int j = -1;
10     next[0] = -1;
11 
12     while (i < pattern_len - 1)
13     {
14 
15         if (j == -1 || pattern[i] == pattern[j])
16         {
17             ++i;
18             ++j;
19             if (pattern[i] != pattern[j]) //正常情况
20                 next[i] = j;
21             else //特殊情况，这里即为优化之处。考虑下aaaab, 防止4个a形成012在匹配时多次迭代。
22                 next[i] = next[j];
23         }
24         else
25         {
26             j = next[j];
27         }
28     }
29 }
30 
31 static inline bool match(const char *src, const char *pattern)
32 {
33     bool is_match = true;
34 
35     int src_index = 0;
36     int pattern_index = 0;
37     int src_len = strlen(src);
38     int pattern_len = strlen(pattern);
39 
40     //创建next数组，并初始化
41     int *next = (int *)malloc(pattern_len * sizeof(int));
42     getNext(pattern, next, pattern_len);
43 
44     //匹配主循环体
45     while (pattern_index < pattern_len && src_index < src_len)
46     {
47         //若对应位置字符匹配则右移1位，否则移动pattern
48         if (pattern_index == -1 || src[src_index] == pattern[pattern_index])
49         {
50             src_index++;
51             pattern_index++;
52         }
53         else
54         {
55             pattern_index = next[pattern_index];
56         }
57     }
58 
59     //若pattern_index未达到串尾，表明pattern未完成匹配。否则即是完成匹配
60     if (pattern_index >= pattern_len)
61     {
62         is_match = true;
63     }
64     else
65     {
66         is_match = false;
67     }
68 
69     return is_match;
70 }
71 
72 
73 int main(void)
74 {
75     char src[] = "aaaabacdeg";
76     char pattern[] = "aabacd";
77 
78     bool res = match(src, pattern);
79     printf("res: %d\n", (int)res);
80 
81     return 0;
82 }