kmp 算法原理

朴素算法

先看看最“朴素”的算法： ///find a template in a string #include<stringh> #include<stdioh> int Index(char S, char T, int pos) { int k=pos, j=0; while(k <strlen(S) && j<strlen(T))//未超出字符串的长度 { if (S[k] == T[j]) { ++k; ++j;} //如果相同，则继续向后比较 else {k = k-j+1; j =0;} //如果不同，就回溯，重新查找 } if (j == strlen(T)) return k-strlen（T）; else return 0; }

编辑本段KMP算法

一种由Knuth(DEKnuth)、Morris(JHMorris)和Pratt(VRPratt)三人设计的线性时间字符串匹配算法。这个算法不用计算变迁函数δ，匹配时间为Θ(n)，只用到辅助函数π[1，m]，它是在Θ(m)时间内，根据模式预先计算出来的。数组π使得我们可以按需要，“现场”有效的计算(在平摊意义上来说)变迁函数δ。粗略地说，对任意状态q=0，1，…，m和任意字符a∈Σ，π[q]的值包含了与a无关但在计算δ(q，a)时需要的信息。由于数组π只有m个元素，而δ有Θ(m∣Σ∣)个值，所以通过预先计算π而不是δ，使得时间减少了一个Σ因子。[1] KMP算法是通过分析子串，预先计算每个位置发生不匹配的时候，所需GOTO的下一个比较位置，整理出来一个next数组，然后在上面的算法中使用。

编辑本段KMP算法的讲解

当我们分析一个子串时，例如：abcabcddes 需要分析一下，每个字符x前面最多有多少个连续的字符和字符串从初始位置开始的字符匹配。然后+1就行了（别忘了，我们的字符串都是从索引1开始的）当然，不要相同位置自己匹配，默认第一个字符的匹配数是0。

编辑本段定义

设字符串为 x1x2x3xn ,其中x1，x2，x3， xi， xn均是字符，设ai为字符xi对应的整数。则a=m，当且仅当满足如下条件：字符串x1x2xm equals 字符串x(i-m+1)xi-1 xi 并且x1x2xm x(m+1) unequals x(i-m) x(i-m+1)xi-1 xi。

编辑本段举例

abcabcddes 0111234111 |----------------------默认是0 --| | |-----------------不能自己在相同位置进行字符匹配，所以这里认为没有匹配字符串，所以0+1 =1，继续从1开始匹配 ------| | |-----------前面的字符和开始位置的字符相同，所以是2,3,4 -----------| | | |-------不匹配只能取1。 希望能明白的是，如果开始字符是 Ch1的话，那么我们就是要在串中第2个Ch1后面的位置开始自己和自己匹配，计算最大的吻合度。 程序写出来就是： void GetNext(char T, int next) { int k=1,j=0; next[1]=0; while( k〈 T[0] ){ if (j ==0 || T[k] == T[j]) { ++k; ++j; next[k] = j; } else j= next[j]; } } 但是这个不是最优的，因为他没有考虑aaaaaaaaaaaaaaaaaaab的情况，这样前面会出现大量的1，这样的算法复杂度已经和最初的朴素算法没有区别了。所以稍微改动一下： void GetNextEx(char T, char next) { int k=1,j=0; next[1] = 0; while(k < T[0]) { if (j == 0 || T[k] == T[j]) { ++k; ++j; if (T[k] == T[j]) next[k] = next[j]; else next[k] = j; } else j = next[j]; } } 现在我们已经可以得到这个next字符串的值了，接下来就是KMP算法的本体了： 相当简单： int KMP(char S, char T, int pos) { int k=pos, j=1; while (k){ if (S[k] == T[j]){ ++k; ++j; } else j = next[j]; } if (j>T[0]) return k-T[0]; else return 0; } 和朴素算法相比，只是修改一句话而已，但是算法复杂度从O(mn) 变成了：O(m)

编辑本段KMP算法的伪代码

KMP-MATCHER(T，P) 1　n ← length[T] 2　m ←length[P] 3　π ← COMPUTE-PREFIX-FUNCTION(P) 4　q ← 0　△Number of characters matched 5　for i ← 1 to n　△Scan the text from left to right 6　do while q>0 and P[q+1]≠T[i] 7　do q ← π[q]　△Next character does not match 8　if P[q+1]=T[i] 9　then q ← q+1　△Next character matches 10　if q=m　△Is all of P matched 11　then print “Pattern occurs with shift” i-m 12　q ← π[q]　△Look for the next match COMPUTE-PERFIX-FUNCTION(P) 1　m ← length[P] 2　π[1] ← 0 3　k ← 0 4　for q ← 2 to m 5　do while k>0 and P[k+1]≠P[q] 6　do k ← π[k] 7　if P[k+1]=P[q] 8　then k ← k+1 9　π[q] ← k 10　return π[1]

编辑本段KMP算法的c++实现

//c++实现的KMP算法，所有涉及字符串，其初始下标从0开始(上述算法均是从1开始) //example: char s[100],t[100];cin>>s>>t;KMP(s,t); //获取待查询模式的next数组 int get_next(char T, int next){ int i = 0, j = -1; int length = strlen(T); int temp = next; next = -1; while(i< length){ if(j==-1 || (T+i)==(T+j)){ i++; j++; //优化后的get_next方法，可以防止出现形如"aaaaab"这种模式的计算退化 if((T+i)!=(T+j)) (next+i)=j; else (next+i)=(next+j); } else j=(next+j); } return temp; } //KMP算法 int KMP(char S, char T){ int S_Length = strlen(S); int T_Length = strlen(T); //若模式长度大于字符串，则直接返回查询失败 if( S_Length < T_Length) return 0; int i = 0, j = 0; int next = new int[T_Length]; get_next(T, next); while(i < S_Length && j < T_Length){ if(j == -1 || (S+i) == (T+j)){ i++; j++; } else j=(next+j); } if(j>=T_Length) return i-T_Length; return 0; } 在此提供一个更简明的适用于字符串的kmp实现： #include<iostream> #include<stringh> int next[100]; void getnext(char b[]) { int i=1,j=0; //i是每个位子，j是回退的位子 next[1]=0; while(i<=strlen(b)) { if(j==0||b[i-1]==b[j-1]) { i++; j++; next[i]=j; } else j=next[j]; //用上一个的 回退关系 } } int kmp(char a[],char b[]) { int i=1,j=1; //i是主串中的位子 ，j匹配串的位子 while(i<=strlen(a)&&j<=strlen(b)) { if(j==0||a[i-1]==b[j-1]) { i++; j++; } else j=next[j]; } if(j>strlen(b)) return i-strlen(b); else return 0; } int main() { char a[40],b[40]; printf("要匹配的主串：\n"); scanf("%s",a); printf("要匹配的子串：\n"); scanf("%s",b); getnext(b); printf("输出next值：\n"); for(int i=1;i<=strlen(b);i++) printf("%d ",next[i]); printf("\n"); printf("%d",kmp(a,b)); system("pause"); main(); return 0; }

编辑本段串的最大匹配算法

摘要：

给定两个串S和T，长分别m和n，本文给出了一个找出二串间最大匹配的算法。该算法可用于比较两个串S和T的相似程度，它与串的模式匹配有别。

关键词：

模式匹配 串的最大匹配 算法 Algorithm on Maximal Matching of Strings Lin YuCai Xiang YongHong Zhang ChunXia Zhang JianJun （Computer Science Department of Yunnan Normal University Kunming 650092） ABSTRACT Given Two Strings S of length m and T of length n，the paper presents an algorithm which finds the maximal matching of them The algorithm can be used to compare the similarility of the two strings S and T, it is different with the strings' pattren matching KEY WORDS Pattern Matching Maximal Matching of Strings Algorithm

编辑本段问题的提出

字符串的模式匹配主要用于文本处理，例如文本编辑。文本数据的存储（文本压缩）和数据检索系统。所谓字符串的模式匹配[2]，就是给定两个字符串S和T，长度分别为m和n，找出T中出现的一个或多个或所有的S，在这方面已经取得了不少进展[3][4][5][6][7][8][9][10][11]。本文从文本处理的另一个角度出发，找出两个串的最大匹配，比较其相似程度[1]。它主要应用于文本比较，特别是在计算机辅助教学中。显然前者要找S的完全匹配，而后者并无此要求。例如，若S=ABCD，T=EFABCDX，那么模式匹配的结果就是找出了T中的一个ABCD，而我们算法的结果就是S能与T的ABCD完全匹配，但是T中还有3个字符是比S多出来的，也就是说在S中有100%的字符与T中的匹配，而在T中有57%的字符与S中的匹配。若S= ABCDFE，T=AFXBECDY。则在模式匹配中S与T无匹配项，但在我们的算法中就能发现T中存在A，B，C，D，但D后不存在E，F。而且S中也存在A，B，C，D，且具有顺序性。这样就能公正地评价S，T的区别。得知其相似程度。 文章的组织如下：首先介绍基本定义和问题的描述；第三节是算法设计；最后是本文总结。

编辑本段问题的描述

设∑为任意有限集，其元称为字符，w：∑→N为∑到N的函数，称为∑的权函数（注：本文仅讨论权值恒为1的情况）。∑为∑上的有限字符串集合，那么对任意S，T∈∑，设S=a1a2…am，T=b1b2…bn，m>0，n>0。记<m>={1,2, …,m},<n>={1,2, …,n}，则称{(i,j)∣i∈<m>，j∈<n>，ai=bj}为S与T的匹配关系集，记作M（S，T），称M为S与T的一个（容许）匹配，若对任意（i,j）, ( i',j' )∈，① i< i'，当且仅当j< j'，② i= i'当且仅当j= j'。S与T的匹配中满足 最大者，称为S与T的最大匹配。若C(i,j)为N上的m×n矩阵，且满足： 则称矩阵C为串S与T的匹配关系阵。 于是求串S与T的最大匹配，等价于求C中的一个最大独立点集M，它满足，若ci,j，ci',j'∈M，则i< i' 当且仅当j< j'，i=i'当且仅当j=j'。我们称这样的最大独立点集为C的最大C-独立点集。 例：设∑为所有字母的集合，对任意x∈∑，w（x）≡1，设S与T分别为：S=“BOOKNEWS”，T=“NEWBOOKS”。则我们可以得到S与T两个匹配： 这里=5； 这里 =4。 显然为串S与T的最大匹配。 S与T的匹配关系阵C可表示如下： 其中带圈的部分为一最大C-独立点集。

编辑本段算法设计

我们仅就权值为一的情况进行讨论。 设S和T为任意给定串，C为的S与T匹配关系阵，那么由2的讨论知，求S与T的最大匹配问题，等价于求C的最大C-独立点集问题。因而，为了解决我们的问题，只要给出求C的最大C-独立点集的算法就可以了。 显然，为了求出C的最大C-独立点集，我们可以采用这样的方法：搜索C的所有C-独立点集，并找出它的最大者。这种方法是可行的，但并不是非常有效的。这会使问题变得很繁，复杂度很大。因此，我们先对问题进行分析。 在下面的讨论中，我们把C的任一C-独立点集={ai1,j1，…，ais,js}，记作=ai1,j1…ais,js，i1 <…< is。于是可看作阵C中以1为节点的一条路，满足：对路中的任意两节点，均有某一节点位于另一节点的右下方。称这种路为右下行路。 于是求C-独立点集等价于求阵C的右下行路。这种求右下行路的搜索可以逐行往下进行。 命题1 若 =αai,jβ和ψ=α'ai,jσ为C的两个C-独立点集，且α为α'的加细，则存在C-独立点集'=αai,jδ，满足≥。 命题2 若 =αai,jβ和ψ=α'ai+k,jσ为C的两个C-独立点集，且≥，则存在C-独立点集'=αai,jδ，满足≥。 命题3 若 =αai,jβ和ψ=α'ai,j+kσ为C的两个C-独立点集，且≥，则存在C-独立点集'=αai,jδ，满足≥。 由命题1知，在搜索右下行路的过程中，如果已获得了某一C-独立点集的某一初始截段αai,j和另一C-独立点集ψ的某一初始截段α'ai,j，且有≤，则我们可以停止对ψ的进一步搜索。 由命题2知，在搜索右下行路的过程中，在某一列j存在某两个C-独立点集的某初始截段=ai1,j1…ais,j和ψ=al1,m1…alt,j，如果≥，但lt>is，则我们可以停止对ψ的进一步搜索。 由命题3知，在搜索右下行路的过程中，在某一行i存在某两个C-独立点集的某初始截段=ai1,j1…ai,js和ψ=ai1,m1…ai,mt，如果≥，但mt>js，则我们可以停止对ψ的进一步搜索。 由此可见，并不要求搜索所有C的最大C-独立点集，而可以采用比这简单得多的方法进行计算。那么按照我们上面的三个命题，来看如下实例： 首先我们得到=B（在上的节点用①表示），我们向右下方找路，可以发现，在第4列有两个1，根据命题2，我们选择上面的一个1，也就是说选择第1行的那个1，而不要第2行的那个1。同时我们也发现在第1行也有两个1，由命题3知，我们选择左边的那个1，即第4列的那个1。此时=BO。但是当我们的算法运行到第4行时，=BOOK，由于K在第3行第6列，而本行的1在第1列，在路最后一个节点K的左边，那么我们必须新建一条路ψ，因为我们并不能确定是否以后就有≥，当算法运行到第6行时，=BOOK，ψ=NEW，=4，=3，我们将S链到路上，此时我们得到最长右下行路=BOOKS，=5。这样我们就可以计算出这两个字符串的匹配程度。 在我们的算法设计过程中，用到了两个技巧。技巧之一，矩阵C不用存储，是动态建立的，节省了空间。技巧之二，本算法并不要求所有的S与T中所有的元素都相互进行比较，也并不存储所有的右下行路，节省了时间和空间。由矩阵中1的出现情况可见，本算法所需的空间和时间都远小于O（mn）

编辑本段结束语

本文给出了一个与模式匹配不同的，具有若干应用的，串的最大匹配算法，该算法已经在机器上实现，达到了预期的效果。本文仅讨论权值恒为1的情况，对于权值任意的情形不难由此得到推广。

编辑本段C语言代码(C Code)

#include<stdioh> #include<stringh> void getnext(int next[],char s[],int l) { int i=1,j=0; next[1]=0; while(i<l) { if(j==0 || s[i]==s[j]) { i++;j++; next[i]=j; } else j=next[j]; } } int KMP(char s1[],char s2[],int l1,int l2,int next[]) { int i,j; i=j=1; while(i<=l1 && j<=l2) { if(j==0||s1[i]==s2[j]) { i++;j++; } else j=next[j]; } if(j>l2) return(i-l2); return 0; } int main() { int next[10001],ans; char s1[10001],s2[10001],l1,l2; scanf("%s",s1+1); scanf("%s",s2+1); l1=strlen(s1+1); l2=strlen(s2+1); getnext(next,s2,l2); ans=KMP(s1,s2,l1,l2,next); if(ans!=0) printf("%d\n",ans); else printf("No!\n"); system("pause"); return 0; }

编辑本段KMP算法的pascal实现

var next:array [1 1000001] of longint; s,t:ansistring; procedure get_next(t:ansistring); 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 inc(j); inc(k); next[j]:=k; end else k:=next[k]; end; end; function index(s:ansistring;t:ansistring):longint; var i,j:longint; 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 inc(i); inc(j); end else j:=next[j]; if j>length(t) then index:=i-length(t); end; end; begin readln(s); readln(t); writeln(index(s,t)) end

编辑本段KMP播放器

K-multimedia player的缩写

来自韩国的影音全能播放器，与Mplayer一样从linux平台移植而来的Kmplayer(简称KMP)几乎可以播放您系统上所有的影音文件。通过各种插件扩展KMP可以支持层出不穷的新格式。强大的插件功能,直接从Winamp继承的插件功能，能够直接使用winamp的音频 ，输入，视觉效果插件，而通过独有的扩展能力，只要你喜欢，可以选择使用不同解码器对各种格式进行解码。 KMPlayer The Professional Media Player! 它支持 Winamp 2/5 的输入、常规、DSP、视觉效果、媒体库插件。无须注册表支持直接调用 Directshow 滤镜！FFdshow 的视觉特效系统~超强的 GUI 界面~安装电视卡后可以直接代替原软件直接收看电视~支持播放 DVD/VCD 以及绝大多数电脑的媒体文件（AVI 支持 Xvid/DivX/3vid/H264 OGG/OGM/MKV 容器/AC3/DTS 解码~Monkey Audio 解码~）强烈推荐！此播放器除了会将自己的配置信息写入注册表外绝对绿色~ KMplayer内置目前常见的所有解码器，包括real,QT等。 另外KMplayer安装版也是目前很少见的检查流氓软件的安装方式，如果一旦有恶意的汉化小组汉化并捆绑了流氓软件。该安装程序自动会识别，并作出提示，建议用户不要安装，虽然不是特别准确，但KMplayer的无广告及第三方插件的特点使其深受好评。 目前韩国官方已经在Kmplayer里自带了中文字库，只要用户是中文系统，软件就会自动识别，十分方便。 KMP版本: KMPlayer3001439

大一下参加学校ACM预备队集训的时候首次接触KMP算法，当时看了很多介绍文章，仍然不是很理解其实质，只是简单地套模板AC题目，待大二数据结构与算法课堂上再听老师介绍一次，才恍然大悟其实KMP也就是那么回事嘛。但当初为啥看那么多文章都没弄明白呢？正巧最近和朋友聊天时他告诉我他对KMP不是很理解，于是打算自己写一篇文章，巩固自己对KMP的认识，也希望能够帮助更多朋友理解KMP。

在开始之前，需要知晓的概念：

前缀：以原串串头为自身串头的子串，如 的前缀有：

后缀：以原串串尾为自身串尾的子串，如 的后缀有：

注意：字符串前后缀都不包括该串本身

给你一个文本串T(Text String)

再给你一个模式串P(Pattern String)

问该模式串是否在文本串中，怎么找？

一开始只好分别从文本串与模式串的串头开始逐字母比较

二者相同，再比较T串与P串的下一位

如此反复

如果一直这么顺利，两串对应位置的字符总相同，待P串中最后一个字符也匹配完毕，说明该模式串在文本串中存在，耶( •̀ ω •́ )y超开心，查找结束。但，大多数匹配过程不会如此顺利，在该例中，当匹配进行至

很明显，失配了。现在怎么办？按朴素思想，将P串相对T串整体右移一位，重新开始匹配，即

但这种算法效率无疑是十分低下的。设T串长度N，P串长度M，则朴素算法时间复杂度为O(MN)

已知的重要信息并没有被使用——已匹配的字符串前缀

在上例中，当P串最后一个字符匹配失败时，其已有包含七个字符的 前缀子串S 匹配成功

完全可以利用前缀子串S做点什么。观察到在S串

中，有相同前后缀，即下图蓝色部分

而S串各字符又与T串中对应字符相同，即有

当失配发生后，直接将P串右移四位使S串蓝色后缀部分对齐T串中蓝色前缀部分

从图中红框部分继续尝试匹配，发现再次失配。这次，已匹配成功的前缀串S为

而在该串中没有相同的前后缀，只能将P串串头移至失配处进行比较

再次失配。此时前缀串S为空串，只好如朴素算法般将P串整体右移一位，重新开始比较

匹配成功。于是又按照之前的步骤往下匹配，直至再次失配或匹配成功

后续步骤同上，不再赘述

上述示例已展现，KMP算法的精髓在于对已匹配成功的前缀串S的利用

在朴素算法中，匹配失败了，T串待匹配字符会回溯

T串原本已匹配至T[7] = 'X'，但是因为失配，需回溯到T[1] = 'b'重新开始匹配

而在KMP算法中，若P[M]与T[K]匹配失败，K不会回溯。既然匹配过程是从T[0]开始逐渐向右进行的，至T[K]失配发生时，T[0]至T[K-1]早已匹配过，何必再回溯过去重复匹配呢？于是乎，就如问题引入部分展示般

每当失配发生，我们总是去关注P串中已匹配成功的前缀串S

因为该前缀串是匹配成功的，说明在T串中必定存在与该前缀串相同的子串，记为S'

若S串中存在相同前后缀

则S'串必然也存在此相同前后缀

所以只需将P串右移四位，使得S串的该相同前缀对齐S'串的该相同后缀

再尝试比较T[7]与P[3]

至于T[7]与P[3]是否能够匹配另说（当然，本例中一看就知道没匹配上），但通过对前缀串S的利用，成功省去了P串右移一位、两位和三位后的无效匹配

继续深入思考，给定一个具体的P串，其第N位的前缀串S内容是固定的，则S是否存在相同前后缀、相同前后缀的长度与内容也是确定的。换言之，对于一个具体的P串，当其与给定T串匹配至P[N]失配，P串应右移几位再次与T串进行匹配也是确定的。我们完全可以使用一个数组记录当P[N]失配后，应当使用N之前的哪一位再来与T串进行匹配，以此提高匹配效率，记该数组为Next数组

定义Next[i] = j表示当P串中第i位失配后，跳转至P串第j位再次尝试匹配

还是以之前的P串为例，它的Next数组求出来应为

取下标5为例，其前缀串为

最长相同前后缀为

若P[5]失配，应跳转至P[1]再次尝试匹配（最长相同前缀对应P[0]，则取其后一位P[1]，若存在多位，则取最后一位的下一位），P[5]的前一个字符P[4]对应字符'a'，而P[1]前一个字符P[0]同对应字符'a'，保证了P[1]之前字符与T串中对应字符保持匹配。所以Next[5] = 1，其余下标对应Next数组值同如此求。

特别地，规定Next[0] = -1。而对于除下标0外的任意下标N，Next[N]的含义是 前N-1个已匹配成功的字符构成的前缀串S中，最长相同前后缀长度。 所以若在下标为N处匹配失败了，则应前往Next[N]所对应的下标处匹配。

具体地，以下图所示为例，P[6]与T[6]失配

而Next[6] = 2，所以使用P[2]再次尝试与T[6]进行匹配

当求出P串Next数组后，便可快速进行与T串的匹配

现在问题只剩下如何求Next数组，注意到Next数组既然只与P串本身相关，与文本串T无关，故令P串与自身匹配即可求得

考虑字符串

其Next数组应为

令其与给定文本串相匹配

当匹配进行至

失配，于是跳转至P[Next[3]] = P[1]处再次尝试匹配

再度失配，也必然失配

问题在于不该出现P[N] =P[Next[N]]

若P[N] =P[Next[N]]，则P[N]失配后使用P[Next[N]]再次尝试匹配，由于P[N] =P[Next[N]]，P[N]匹配失败，P[Next[N]]必然也失败

因此，若出现P[N] =P[Next[N]]情况，则令Next[N]=Next[Next[N]]

本例中该字符串新Next数组为

当匹配进行至

失配，于是跳转至P[Next[3]] = P[0]处再次尝试匹配

省去了之前跳转至P[1]处的无效匹配

设T串长度M，P串长度N，由于KMP算法不会回溯，分析易知时间复杂度为O(m+n)

对于P[N]，若其前缀串S含相同前后缀F，且F长度为n（n>1），Next[N]可以取1至n中任意值，为最大化匹配效率考虑，总是取最大相同前后缀以提高效率，节省时间

KMP模式匹配算法

KMP算法是一种改进的字符串匹配算法,其关键是利用匹配失败后的信息,尽量减少模式串与主串的匹配次数以达到快速匹配的目的明[4]。

求得模式的特征向量之后，基于特征分析的快速模式匹配算法(KMP模式匹配算法)与朴素匹配算法类似，只是在每次匹配过程中发生某次失配时，不再单纯地把模式后移一位，而是根据当前字符的特征数来决定模式右移的位数[3]。

include "string h"

#include<assert h>

int KMPStrMatching(String T, String P, int N, int startIndex)

{int lastIndex=Tstrlen() -Pstrlen();

if((1 astIndex- startIndex)<0)//若 startIndex过大,则无法匹配成功

return (-1);//指向P内部字符的游标

int i;//指向T内部字符的游标

int j=0;//指向P内部字符的游标

for(i= startIndex; i <Tstrlen(); i++)

{while(P[j]!=T[i]&& j>0)

j=N[j-1];

if(P[j]==T[i])

j++;

if(j ==Pstrlen())

return(1-j+1);//匹配成功,返回该T子串的开始位置

}

return (-1);

}

以上就是关于kmp 算法原理全部的内容，包括:kmp 算法原理、算法-KMP、kmp算法详解等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！