KMP算法详解

时间 2019-12-06

标签 kmp 算法详解繁體版

原文原文链接

前言

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

简介

该算法是一种改进的字符串匹配算法，由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算法的关键思想就是，设法利用这个已知信息，不要把"搜索位置"移回已经比较过的位置，继续把它向后移，这样就提升了效率。google

怎么作到这一点呢？能够针对搜索字符串，算出一张《部分匹配表》（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 }

备注

本文有至关分量的内容参考借鉴了网络上各位网友的热心分享，特别是一些带有彻底参考的文章，其后附带的连接内容更直接、更丰富，笔者只是作了一下概括&转述，在此一并表示感谢。

参考

《字符串匹配的KMP算法》

《从头至尾完全理解KMP》

《KMP算法的前缀next数组最通俗的解释》