# 经典算法研究系列：六、教你初步了解KMP算法、updated

43 篇文章 3907 订阅

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

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

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

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

#include<iostream>
#include<string>
using namespace std;
int match(const string& target,const string& pattern)
{
int target_length = target.size();
int pattern_length = pattern.size();
int target_index = 0;
int pattern_index = 0;
while(target_index < target_length && pattern_index < pattern_length)
{
if(target[target_index]==pattern[pattern_index])
{
++target_index;
++pattern_index;
}
else
{
target_index -= (pattern_index-1);
pattern_index = 0;
}
}
if(pattern_index == pattern_length)
{
return target_index - pattern_length;
}
else
{
return -1;
}
}
int main()
{
cout<<match("banananobano","nano")<<endl;
return 0;
}

//运行结果为4。

kmp算法就是从此出发。

2.1、 覆盖函数(overlay_function)

a0a1...aj-1 aj

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

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

⑴     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)过程.

#include<iostream>
#include<string>
using namespace std;
void compute_overlay(const string& pattern)
{
const int pattern_length = pattern.size();
int *overlay_function = new int[pattern_length];
int index;
overlay_function[0] = -1;
for(int i=1;i<pattern_length;++i)
{
index = overlay_function[i-1];
//store previous fail position k to index;

while(index>=0 && pattern[i]!=pattern[index+1])
{
index = overlay_function[index];
}
if(pattern[i]==pattern[index+1])
{
overlay_function[i] = index + 1;
}
else
{
overlay_function[i] = -1;
}
}
for(i=0;i<pattern_length;++i)
{
cout<<overlay_function[i]<<endl;
}
delete[] overlay_function;
}
int main()
{
string pattern = "abaabcaba";
compute_overlay(pattern);
return 0;
}

-1
-1
0
0
1
-1
0
1
2
Press any key to continue

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

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

如果失配时pattern_index==0，相当于pattern第一个字符就不匹配，

ok，下图就是KMP算法的过程（红色即是采用KMP算法的执行过程）：

KMP 算法可在O（n+m）时间内完成全部的串的模式匹配工作。

ok，最后给出KMP算法实现的c++代码：

#include<iostream>
#include<string>
#include<vector>
using namespace std;

int kmp_find(const string& target,const string& pattern)
{
const int target_length = target.size();
const int pattern_length = pattern.size();
int * overlay_value = new int[pattern_length];
overlay_value[0] = -1;
int index = 0;
for(int i=1;i<pattern_length;++i)
{
index = overlay_value[i-1];
while(index>=0 && pattern[index+1]!=pattern[i])
{
index  = overlay_value[index];
}
if(pattern[index+1]==pattern[i])
{
overlay_value[i] = index +1;
}
else
{
overlay_value[i] = -1;
}
}
//match algorithm start
int pattern_index = 0;
int target_index = 0;
while(pattern_index<pattern_length&&target_index<target_length)
{
if(target[target_index]==pattern[pattern_index])
{
++target_index;
++pattern_index;
}
else if(pattern_index==0)
{
++target_index;
}
else
{
pattern_index = overlay_value[pattern_index-1]+1;
}
}
if(pattern_index==pattern_length)
{
return target_index-pattern_index;
}
else
{
return -1;
}
delete [] overlay_value;
}

int main()
{
string pattern = " annacanna";
cout<<kmp_find(source,pattern)<<endl;
return 0;
}
//运行结果为 -1.

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

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

KMP算法：

KMP就是串匹配算法

P{ababbaaba}

[2]ababbaaba

.......ababbaaba[1]

[3]ababbaaba

.........ababbaaba[1]

[4]ababbaaba

.........ababbaaba[2]

[5]ababbaaba

.........ababbaaba[3]

[6]ababbaaba

................ababbaaba[1]

[7]ababbaaba

................ababbaaba[2]

[8]ababbaaba

..................ababbaaba[2]

[9]ababbaaba

..................ababbaaba[3]

[1]i:=1 j:=1

[2](j>m)(i>n)[4]否则转[3]

[3]j=0a[i]=b[j]则【inc(i)inc(j)[2]】否则【j:=next[j]2

[4]j>mreturn(i-m)否则return -1;

BM算法也是一种快速串匹配算法，KMP算法的主要区别是匹配操作的方向不同。虽然T右移的计算方法却发生了较大的变化。

Horspool算法

SUNDAY算法：
BM

BM

SUNDAY

substring searching algorithm
search
^

substring searching algorithm
search
^

substring searching algorithm
search
^

#include<iostream>
#include<fstream>
#include<vector>
#include<algorithm>
#include<string>
#include<list>
#include<functional>

using namespace std;

int main()
{
char *text=new char[100];
text="substring searching algorithm search";
char *patt=new char[10];
patt="search";
size_t temp[256];
size_t *shift=temp;

size_t patt_size=strlen(patt);
cout<<"size : "<<patt_size<<endl;
for(size_t i=0;i<256;i++)
*(shift+i)=patt_size+1;//所有值赋于7，对这题而言

for(i=0;i<patt_size;i++)
*(shift+unsigned char(*(patt+i) ) )=patt_size-i;
/* //       移动3步-->shift['r']=6-3=3;移动三步
//shift['s']=6步,shitf['e']=5以此类推
*/

size_t text_size=strlen(text);
size_t limit=text_size-i+1;

for(i=0;i<limit;i+=shift[text[i+patt_size] ] )
if(text[i]==*patt)
{
/*       ^13--这个r是位，从0开始算
substring searching algorithm
search
searching-->这个s为第10位，从0开始算
如果第一个字节匹配，那么继续匹配剩下的
*/

char* match_text=text+i+1;
size_t     match_size=1;
do{
if(match_size==patt_size)

cout<<"the no is "<<i<<endl;
}while( (*match_text++)==patt[match_size++] );
}

cout<<endl;
}
delete []text;
delete []patt;
return 0;
}

//运行结果如下：
/*
size : 6
the no is 10
the no is 30
Press any key to continue
*/ 

• 9
点赞
• 168
收藏
觉得还不错? 一键收藏
• 打赏
• 73
评论
11-30
08-19 541

### “相关推荐”对你有帮助么？

• 非常没帮助
• 没帮助
• 一般
• 有帮助
• 非常有帮助

v_JULY_v

¥1 ¥2 ¥4 ¥6 ¥10 ¥20

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。