教你从头到尾彻底理解KMP算法

移动开发 算法
本文由简单的字符串匹配算法开始,经Rabin-Karp算法,最后到KMP算法,教你从头到尾彻底理解KMP算法。

[[121931]]

本文参考:数据结构(c语言版) 李云清等编著、算法导论

引言:

在文本编辑中,我们经常要在一段文本中某个特定的位置找出 某个特定的字符或模式。

由此,便产生了字符串的匹配问题。

本文由简单的字符串匹配算法开始,经Rabin-Karp算法,***到KMP算法,教你从头到尾彻底理解KMP算法。

来看算法导论一书上关于此字符串问题的定义:

假设文本是一个长度为n的数组T[1...n],模式是一个长度为m<=n的数组P[1....m]。

进一步假设P和T的元素都是属于有限字母表Σ.中的字符。

依据上图,再来解释下字符串匹配问题。目标是找出所有在文本T=abcabaabcaabac中的模式P=abaa所有出现。

该模式仅在文本中出现了一次,在位移s=3处。位移s=3是有效位移。

一、简单的字符串匹配算法

简单的字符串匹配算法用一个循环来找出所有有效位移,

该循环对n-m+1个可能的每一个s值检查条件P[1....m]=T[s+1....s+m]。

NAIVE-STRING-MATCHER(T, P)

1 n ← length[T]

2 m ← length[P]

3 for s ← 0 to n - m

4 do if P[1 ‥ m] = T[s + 1 ‥ s + m]

//对n-m+1个可能的位移s中的每一个值,比较相应的字符的循环必须执行m次。

5 then print "Pattern occurs with shift" s

简单字符串匹配算法,上图针对文本T=acaabc 和模式P=aab。

上述第4行代码,n-m+1个可能的位移s中的每一个值,比较相应的字符的循环必须执行m次。

所以,在最坏情况下,此简单模式匹配算法的运行时间为O((n-m+1)m)。

--------------------------------

下面我再来举个具体例子,并给出一具体运行程序:

对于目的字串target是banananobano,要匹配的字串pattern是nano,的情况,

下面是匹配过程,原理很简单,只要先和target字串的***个字符比较,

如果相同就比较下一个,如果不同就把pattern右移一下,

之后再从pattern的每一个字符比较,这个算法的运行过程如下图。

//index表示的每n次匹配的情形。

  1. #include<iostream> 
  2. #include<string> 
  3. using namespace std; 
  4. int match(const string& target,const string& pattern) 
  5. int target_length = target.size(); 
  6. int pattern_length = pattern.size(); 
  7. int target_index = 0; 
  8. int pattern_index = 0; 
  9. while(target_index < target_length && pattern_index < pattern_length) 
  10. if(target[target_index]==pattern[pattern_index]) 
  11. ++target_index; 
  12. ++pattern_index; 
  13. else 
  14. target_index -= (pattern_index-1); 
  15. pattern_index = 0; 
  16. if(pattern_index == pattern_length) 
  17. return target_index - pattern_length; 
  18. else 
  19. return -1; 
  20. int main() 
  21. cout<<match("banananobano","nano")<<endl; 
  22. return 0; 
  23. //运行结果为4。

上面的算法进间复杂度是O(pattern_length*target_length),

我们主要把时间浪费在什么地方呢,

观查index =2那一步,我们已经匹配了3个字符,而第4个字符是不匹配的,这时我们已经匹配的字符序列是nan,

此时如果向右移动一位,那么nan***匹配的字符序列将是an,这肯定是不能匹配的,

之后再右移一位,匹配的是nan***匹配的序列是n,这是可以匹配的。

如果我们事先知道pattern本身的这些信息就不用每次匹配失败后都把target_index回退回去,

这种回退就浪费了很多不必要的时间,如果能事先计算出pattern本身的这些性质,

那么就可以在失配时直接把pattern移动到下一个可能的位置,

把其中根本不可能匹配的过程省略掉,

如上表所示我们在index=2时失配,此时就可以直接把pattern移动到index=4的状态,

kmp算法就是从此出发。

二、KMP算法

1、 覆盖函数(overlay_function)

覆盖函数所表征的是pattern本身的性质,可以让为其表征的是pattern从左开始的所有连续子串的自我覆盖程度。

比如如下的字串,abaabcaba

由于计数是从0始的,因此覆盖函数的值为0说明有1个匹配,对于从0还是从来开始计数是偏好问题,

具体请自行调整,其中-1表示没有覆盖,那么何为覆盖呢,下面比较数学的来看一下定义,比如对于序列

a0a1...aj-1 aj

要找到一个k,使它满足

a0a1...ak-1ak=aj-kaj-k+1...aj-1aj

而没有更大的k满足这个条件,就是说要找到尽可能大k,使pattern前k字符与后k字符相匹配,k要尽可能的大,

原因是如果有比较大的k存在,而我们选择较小的满足条件的k,

那么当失配时,我们就会使pattern向右移动的位置变大,而较少的移动位置是存在匹配的,这样我们就会把可能匹配的结果丢失。

比如下面的序列,

在红色部分失配,正确的结果是k=1的情况,把pattern右移4位,如果选择k=0,右移5位则会产生错误。

计算这个overlay函数的方法可以采用递推,可以想象如果对于pattern的前j个字符,如果覆盖函数值为k

a0a1...ak-1ak=aj-kaj-k+1...aj-1aj

则对于pattern的前j+1序列字符,则有如下可能

⑴ pattern[k+1]==pattern[j+1] 此时overlay(j+1)=k+1=overlay(j)+1

⑵ pattern[k+1]≠pattern[j+1] 此时只能在pattern前k+1个子符组所的子串中找到相应的overlay函数,h=overlay(k),如果此时pattern[h+1]==pattern[j+1],则overlay(j+1)=h+1否则重复(2)过程.

下面给出一段计算覆盖函数的代码:

 

  1. #include<iostream> 
  2. #include<string> 
  3. using namespace std; 
  4. void compute_overlay(const string& pattern) 
  5. const int pattern_length = pattern.size(); 
  6. int *overlay_function = new int[pattern_length]; 
  7. int index; 
  8. overlay_function[0] = -1; 
  9. for(int i=1;i<pattern_length;++i) 
  10. index = overlay_function[i-1]; 
  11. //store previous fail position k to index; 
  12. while(index>=0 && pattern[i]!=pattern[index+1]) 
  13. index = overlay_function[index]; 
  14. if(pattern[i]==pattern[index+1]) 
  15. overlay_function[i] = index + 1; 
  16. else 
  17. overlay_function[i] = -1; 
  18. for(i=0;i<pattern_length;++i) 
  19. cout<<overlay_function[i]<<endl; 
  20. delete[] overlay_function; 
  21. int main() 
  22. string pattern = "abaabcaba"
  23. compute_overlay(pattern); 
  24. return 0; 

运行结果为:

-1

-1

0

0

1

-1

0

1

2

Press any key to continue

-------------------------------------

2、kmp算法

有了覆盖函数,那么实现kmp算法就是很简单的了,我们的原则还是从左向右匹配,但是当失配发生时,我们不用把target_index向回移 动,target_index前面已经匹配过的部分在pattern自身就能体现出来,只要动pattern_index就可以了。

当发生在j长度失配时,只要把pattern向右移动j-overlay(j)长度就可以了。

如果失配时pattern_index==0,相当于pattern***个字符就不匹配,

这时就应该把target_index加1,向右移动1位就可以了。

ok,下图就是KMP算法的过程(红色即是采用KMP算法的执行过程):

ok,***给出KMP算法实现的c++代码:

  1. #include<iostream> 
  2. #include<string> 
  3. #include<vector> 
  4. using namespace std; 
  5. int kmp_find(const string& target,const string& pattern) 
  6. const int target_length = target.size(); 
  7. const int pattern_length = pattern.size(); 
  8. int * overlay_value = new int[pattern_length]; 
  9. overlay_value[0] = -1; 
  10. int index = 0; 
  11. for(int i=1;i<pattern_length;++i) 
  12. index = overlay_value[i-1]; 
  13. while(index>=0 && pattern[index+1]!=pattern[i]) 
  14. index = overlay_value[index]; 
  15. if(pattern[index+1]==pattern[i]) 
  16. overlay_value[i] = index +1; 
  17. else 
  18. overlay_value[i] = -1; 
  19. //match algorithm start 
  20. int pattern_index = 0; 
  21. int target_index = 0; 
  22. while(pattern_index<pattern_length&&target_index<target_length) 
  23. if(target[target_index]==pattern[pattern_index]) 
  24. ++target_index; 
  25. ++pattern_index; 
  26. else if(pattern_index==0) 
  27. ++target_index; 
  28. else 
  29. pattern_index = overlay_value[pattern_index-1]+1; 
  30. if(pattern_index==pattern_length) 
  31. return target_index-pattern_index; 
  32. else 
  33. return -1; 
  34. delete [] overlay_value; 
  35. int main() 
  36. string source = " annbcdanacadsannannabnna"
  37. string pattern = " annacanna"
  38. cout<<kmp_find(source,pattern)<<endl; 
  39. return 0; 
  40. //运行结果为 -1. 

三、kmp算法的来源

kmp如此精巧,那么它是怎么来的呢,为什么要三个人合力才能想出来。其实就算没有kmp算法,人们在字符匹配中也能找到相同高效的算法。这种算法,最终 相当于kmp算法,只是这种算法的出发点不是覆盖函数,不是直接从匹配的内在原理出发,而使用此方法的计算的覆盖函数过程序复杂且不易被理解,但是一但找 到这个覆盖函数,那以后使用同一pattern匹配时的效率就和kmp一样了,其实这种算法找到的函数不应叫做覆盖函数,因为在寻找过程中根本没有考虑是 否覆盖的问题。

说了这么半天那么这种方法是什么呢,这种方法是就大名鼎鼎的确定的有限自动机(Deterministic finite state automaton DFA),DFA可识别的文法是3型文法,又叫正规文法或是正则文法,既然可以识别正则文法,那么识别确定的字串肯定不是问题(确定字串是正则式的一个子 集)。对于如何构造DFA,是有一个完整的算法,这里不做介绍了。在识别确定的字串时使用DFA实在是大材小用,DFA可以识别更加通用的正则表达式,而 用通用的构建DFA的方法来识别确定的字串,那这个overhead就显得太大了。

kmp算法的可贵之处是从字符匹配的问题本身特点出发,巧妙使用覆盖函数这一表征pattern自身特点的这一概念来快速直接生成识别字串的DFA,因此对于kmp这种算法,理解这种算法高中数学就可以了,但是如果想从无到有设计出这种算法是要求有比较深的数学功底的。

原文:http://www.2cto.com/kf/201104/87381.html

作者声明:个人July 对此24个经典算法系列,享有版权,转载请注明出处。

责任编辑:闫佳明 来源: 2cto
相关推荐

2013-10-10 10:34:47

哈希算法

2013-05-02 11:21:36

iOS开发流程

2021-11-08 17:03:13

IO模型

2015-09-21 09:48:48

私有云云架构云管理

2021-04-21 10:00:08

MySQL索引数据库

2019-08-21 08:54:46

垃圾回收Java算法

2016-03-09 09:42:15

App产品经理项目启动

2014-12-24 11:34:23

CoreOSWordPress集群部署

2022-04-24 11:06:54

SpringBootjar代码

2021-09-07 07:55:22

Linux CPULinux 系统

2017-03-25 21:13:38

JavaScript排序

2021-08-09 06:57:42

代码重定位Linux

2020-05-28 08:59:40

Python机器学习开发

2021-05-13 08:55:33

Android架构功能

2020-08-17 09:25:51

Docker容器技术

2013-01-17 10:35:57

虚拟机生命周期管理

2019-11-07 10:37:36

CookieSessionToken

2019-02-20 13:57:48

游戏服务器框架

2024-03-15 08:23:26

异步编程函数

2019-12-23 14:32:38

Java内部类代码
点赞
收藏

51CTO技术栈公众号