kmp算法是一种改进的字符串匹配算法，由D.E.Knuth与V.R.Pratt和J.H.Morris同时发现，因此人们称它为克努特——莫里斯——普拉特操作（简称KMP算法）。KMP算法的关键是根据给定的模式串W1,m,定义一个next函数。next函数包含了模式串本身局部匹配的信息。

详细算法(一般的KMP算法 KMP算法的优化)

基本思想

BM算法

BM算法基本思想

详细算法

一般的KMP算法

现在讨论一般情况。

假设

主串： s: ‘s(1) s(2) s(3) ……s(n)’ ;

模式串 ：p: ‘p(1) p(2) p(3)…..p(m)’

把课本上的这一段看完后，继续

现在我们假设 主串第i个字符与模式串的第j(j<=m)个字符‘失配’后，主串第i个字符与模式串的第k(k<j)个字符继续比较

此时，s(i)≠p(j), 有

主串： s(1)…… s(i-j+1)…… s(i-1) s(i) ………….

|| (相配) || ≠(失配)

匹配串： p(1) ...........p(j-1) p(j)

由此，我们得到关系式：

‘p(1) p(2) p(3)…..p(j-1)’ = ’ s(i-j+1)……s(i-1)’

由于s(i)≠p(j)，接下来s(i)将与p(k)继续比较，则模式串中的前(k-1)个字符的子串必须满足下列关系式，并且不可能存在 k’>k 满足下列关系式：(k<j),

‘p(1) p(2) p(3)…..p(k-1)’ = ’ s(i-k+1)s(i-k+2)……s(i-1)’

即：

主串： s(1)……s(i-k +1) s(i-k +2) ……s(i-1) s(i) ………….

|| (相配) || || ?(有待比较)

匹配串： p(1) p(2) ……..... p(k-1) p(k)

现在我们把前面总结的关系综合一下

有：

s(1)…s(i-j +1)… s(i-k +1) s(i-k +2) …… s(i-1) s(i) ……

|| (相配) || || || ≠(失配)

p(1) ……p(j-k+1) p(j-k+2) …...... p(j-1) p(j)

|| (相配) || || ?(有待比较)

p(1) p(2) ……...... p(k-1) p(k)

由上，我们得到关系：

'p(1) p(2) p(3)…..p(k-1)’ = ' p(j-k+1)p(j-k+2)……p(j-1)’

接下来看“反之，若模式串中存在满足式(4-4)。。。。。。。”这一段。看完这一段，如果下面的看不懂就不要看了。直接去看那个next函数的源程序。(伪代码)

K 是和next有关系的，不过在最初看的时候，你不要太追究k到底是多少，至于next值是怎么求出来的，我教你怎么学会。

课本83页不是有个例子吗？就是 图4.6

你照着源程序，看着那个例子慢慢的推出它来。看看你做的是不是和课本上正确的next值一样。

在理解上面代码的基础上，建议自己寻找一些KMP算法的练习，也可以自己写两个较为简单的字符串进行人脑模拟这种方法的练习，以加深对算法的理解。

KMP算法的优化

KMP算法是可以被进一步优化的。

我们以一个例子来说明。譬如我们给的P字符串是“abcdaabcab”，经过KMP算法，应当得到“特征向量”如下表所示：

下标i　0　1　2　3　4　5　6　7　8　9

p(i)　a　b　c　d　a　a　b　c　a　b

next[i]　-1　0　0　0　0　1　1　2　3　1但是，如果此时发现p(i) == p(k)，那么应当将相应的next[i]的值更改为next[k]的值。经过优化后可以得到下面的表格：

下标i　0　1　2　3　4　5　6　7　8　9

p(i)　a　b　c　d　a　a　b　c　a　b

next[i]　-1　0　0　0　0　1　1　2　3　1

优化的next[i]　-1　0　0　0　-1　1　0　0　3　0附：

KMP算法查找串S中含串P的个数count

#include <iostream>

#include <stdlib.h>

#include <vector>

using namespace std;

inline void NEXT(const string& T,vector<int>& next)

{

//按模式串生成vector,next(T.size())

next[0]=-1;

for(int i=1;i<T.size();i++ ){

int j=next[i-1];

while(T[i]!=T[j+1]&& j>=0 )

j=next[j] ; //递推计算

if(T[i]==T[j+1])next[i]=j+1;

else next[i]=0; //

}

}

inline string::size_typeCOUNT_KMP(const string& S,

const string& T)

{

//利用模式串T的next函数求T在主串S中的个数count的KMP算法

//其中T非空，

vector<int> next(T.size());

NEXT(T,next);

string::size_type index,count=0;

for(index=0;index<S.size();++index){

int pos=0;

string::size_type iter=index;

while(pos<T.size() && iter<S.size()){

if(S[iter]==T[pos]){

++iter;++pos;

}

else{

if(pos==0)++iter;

else pos=next[pos-1]+1;

}

}//while end

if(pos==T.size()&&(iter-index)==T.size())++count;

} //for end

return count;

}

int main(int argc, char *argv[])

{

string S="abaabcacabaabcacabaabcacabaabcacabaabcac";

string T="ab";

string::size_type count=COUNT_KMP(S,T);

cout<<count<<endl;

system("PAUSE");

return 0;

}

补上个Pascal的KMP算法源码

PROGRAM Impl_KMP;

USES

CRT;

CONST

MAX_STRLEN = 255;

VAR

next : array [ 1 .. MAX_STRLEN ] of integer;

str_s, str_t : string;

int_i : integer;

Procedure get_nexst( t : string );

Var

j, k : integer;

Begin

j := 1; k := 0;

while j < Length(t) do

begin

if ( k = 0 ) or ( t[j] = t[k] ) then

begin

j := j + 1; k := k + 1;

next[j] := k;

end

else k := next[k];

end;

End;

Function index( s : string; t : string ) : integer;

Var

i, j : integer;

Begin

get_next(t);

index := 0;

i := 1; j := 1;

while ( i <= Length(s) ) and ( j <= Length(t) ) do

begin

if ( j = 0 ) or ( s[i]= t[j] ) then

begin

i := i + 1; j := j + 1;

end

else j := next[j];

if j > Length(t) then index := i - Length(t);

end;

End;

BEGIN

ClrScr;{清屏，可不要}

Write(‘s = ’);

Readln(str_s);

Write(‘t = ’);

Readln(str_t);

int_i := index( str_s, str_t );

if int_i <> 0 then

begin

Writeln( 'Found' , str_t,' in ', str_s, 'at ', int_i,' .' );

end

else

Writeln( 'Cannot find ', str_t,' in' , str_s, '. ');

END.

index函数用于模式匹配，t是模式串，s是原串。返回模式串的位置，找不到则返回0

基本思想

假设在模式匹配的进程中，执行T[i]和W[j]的匹配检查。若T[i]=W[j]，则继续检查T[i+1]和W[j+1]是否匹配。若T[i]<>W[j]，则分成两种情况：若j=1，则模式串右移一位，检查T[i+1]和W[1]是否匹配；若1<j<=m，则模式串右移j-next(j)位，检查T[i]和W[next(j)]是否匹配。重复此过程直到j=m或i=n结束。

文献中，朱洪对KMP算法作了修改，他修改了KMP算法中的next函数，即求next函数时不但要求W[1,next(j)-1]=W[j-(next(j)-1),j-1]，而且要求W[next(j)]<>W[j]，他记修改后的next函数为newnext。显然在模式串字符重复高的情况下,朱洪的KMP算法比KMP算法更加有效。

以下给出朱洪的改进KMP算法和next函数和newnext函数的计算算法。

算法1.1：KMP串匹配算法

输入: 正文串j和模式串W[1,m]

输出: 匹配结果match[1,n]

procedure KMP

begin

i=1

j=1

while i<=n do

while j<>0 and W[j]<>T[i] do

j=newnext[j]

endwhile

if j=m

return “success”

else

j++

i++

endif

endwhile

return “failure”

end

算法1.2: next函数和newnext函数的计算算法

输入: 模式串W[1,m]

输出: next[1,m+1]和newnext[1,m]

function NEXT

begin

next[1]=newnext[1]=0

j=2

while j<=m do

i=next[j-1]

while i<>0 and W[i]<>W[j-1]) do

i=next[i]

endwhile

next[j]=i+1

j=j+1

endwhile

end

function NEWNEXT

begin

newnext(1)=0

j=2

while j<=m do

i=next(j)

if i=0 or W[j]<>W[i+1]

newnext[j]=i

else

newnext[j]=newnext[i]

endif

j++

endwhile

end

朱洪证明了算法1的时间复杂度为O(n)，算法2的时间复杂度为O(m)。

更加简洁的算法

下面是更加简洁的算法：

void GetNext(char T[ ],int next[ ])

{

next[1]=0;

j=1;k=0;

while(j<T[0])

if ((k==0)||(T[j]==T[k])

{ j++;

k++;

next[j]=k;

}

else k=next[k];

}

BM算法

BM算法和KMP算法的差别是对模式串的扫描方式自左至右变成自右至左。另一个差别是考虑正文中可能出现的字符在模式中的位置。这样做的好处是当正文中出现模式中没有的字符时就可以将模式大幅度滑过正文。

BM算法的关键是根据给定的模式W[1,m],，定义一个函数d: x->{1,2,…,m} ,这里x∈∑。函数d给出了正文中可能出现的字符在模式中的位置。

BM算法基本思想

假设在执行正文中自位置i起“返前”的一段与模式的自右至左的匹配检查中，一旦发现不匹配(不管在什么位置)，则去执行由Wm与ti+d(x)起始的自右至左的匹配检查，这里x是字符t。。它的效果相当于把模式向右滑过d(ti)一段距离。显然,若ti不在模式中出现或仅仅在模式末端出现，则模式向右滑过的最大的一段距离m。图1.1示出了执行BM算法时的各种情况。实线连接发现不匹配以后要进行比较的正文和模式中的字母，虚线连接BM算法在模式向右滑后正文和模式中应对齐的字母，星号表示正文中的一个字母。

图1.1：执行BM算法时的各种情况

BM算法由算法1.3给出，函数d的算法由算法1.4给出。计算函数d的时耗显然是Θ(m)。BM算法的最坏情况时耗是Θ(mn)。但由于在实用中这种情况极少出现，因此BM算法仍广泛使用。

算法1.3：BM串匹配算法

输入: 正文串W[1,m]和模式串T[1,n]

输出: 匹配结果match[1,n]

procedure BM

begin

i=m

Repeat

j=m

k=i

while(j>0)and(w[j]=t[k]) do

j=j-1

k=k-1

endwhile

i=i+d[t[i]]

Until (j=0)or(i>n)

If j=0 return “SUCCESS”

else return “FAILURE”

endif

end

算法1.4: d函数计算法:

function d:integer;

begin

for x∈∑ do d(x)=m

for j=m-1 downto 1 do

if d(w[j])=m d(w[j]):=m-j

endfor

end

xi+1=ord(ti+1)dm-1+ord(ti+2)dm-2+…+ord(ti+m)

=(xi-ord(ti)dm-1).d+ord(ti+m)

因此有 h(xi+1)=((h(xi)-x·ord(ti))·d+ord(ti+m)mod q ，i=1,2,……,n-m

这里x是一常数，x=dm-1mod q。 这就是计算每一长度为m的字符段的散列函数值的递推公式。RK串匹配算法由算法1.5给出。

算法1.5：RK串匹配算法

program RK;

begin

{计算x,x:=d↑(m-1) mod q}

x=1

for i=1 to m-1 do x=(32*x)mod q

{计算模式W的散列函数值}

s=0

for i=1 to m do

s=((s*32)+ord(w[i])) mod q

{计算正文T的第一个长度为m的字符段的散列函数值}

t=0

for i=1 to m do

t=(t*32+ord(w[i])) mod q

{如果正文的第一个长度为m的字符段和模式有相同的散列函数值,则进行匹配检查.否则,以及在匹配检查失败情况下,继续计算下一个字符段的散列函数值}

i=1

while i<=n-m do

if s=t

{进行匹配检查}

k=1

j=i

while (t[j]=w[k]) and (k<=m) do

j=j+1

k=k+1

endwhile

if i<n-m {计算下一字符段的散列函数值}

t=((t-x*ord(t[i]))*32+ord(t[i+m])) mod q

i=i+1

endif

endif

endwhile

return “FAILURE”

end

显然,如果不计执行匹配检查的时间，则RK算法的剩余部分执行时间是Θ(m+n)。不过，如果计及执行匹配检查的时间,则在理论上,RK算法需要时耗Θ(mn)。但是,我们总可设法取q适当大，使得mod函数在计算机中仍可执行而冲突(即不同的字符串具有相同的散列值)又极小可能发生，而使算法的实际执行时间只需Θ(m+n)。