模式匹配KMP算法研究报告
模式匹配的KMP算法研究
学生姓名：黄飞指导老师：罗心
摘要在计算机科学领域，串的模式匹配<以下简称为串匹配）算法一直都是研究焦点之一。在拼写检查、语言翻译、数据压缩、搜索引擎、网络入侵检测、计算机病
毒特征码匹配以及DNA序列匹配等应用中，都需要进行串匹配。串匹配就是在主串中
查找模式串的一个或所有出现。在本文中主串表示为S=s1s2s3…sn，模式串表示为
T=t1t2…tm。串匹配从方式上可分为精确匹配、模糊匹配、并行匹配等，著名的匹配
算法有BF算法、KMP算法、BM算法及一些改进算法。本文主要在精确匹配方面对KMP
算法进行了讨论并对它做一些改进以及利用改进的KMP来实现多次模式匹配。
关键字：模式匹配；主串；模式串；KMP算法
Research and Analysis of KMP Pattern Matching
Algorithm
Student:Huangfei Teacher:Luoxin
Abstract In computer science,String pattern matching(Hereinafter referred to as the string matching>algorithmis always the focus of the study.In the
spell check, language translation, data compression, search engine, the
network intrusion detection system, a computer virus signature matching DNA
sequences and the application in the match,matched to string matching.String matching is in search of a string of pattern or all appear.In this paper, the string is S = s1s2s3... Sn, string pattern for T = t1t2... tm.String matching way can be divided from the accurate matching, fuzzy matching, parallel matching etc., the famous matching algorithms are KMP algorithm, BF algorithm, the algorithm and some BM algorithm.This paper in precise KMP algorithm for matching aspects are discussed and some improvement on it and using the improved KMP to realize the multiple pattern matching.
Key words: pattern matching, The string。 Pattern strings。KMP algorithm
1引言
KMP算法是是对一般模式匹配算法的改进，由 D.E.Knuth与V.R.Pratt和J.H.Morris 同时发现的因此人们称它为克努特-莫里斯-莫拉特操作<简称为KMP算法）。
对于一般的模式匹配算法：分别利用两个指针i和j指示主串S和T中的当前正待比较的字符位置。算法的基本思想是：从主串的S的第POS个字符开始起和模式的第一个字符比较之，如相等，则继续逐个比较后续字符；否则从主串的下一个字符起再重新和模式的字符比较之。以此类推，直到模式T中的每个字符依次和主串S中的一个连续字符序列相等，则称匹配成功，则函数值为和模式T中的第一个字符相等的字符在主串S中的序号，否则称匹配不成功，函数值为0.而对于模式匹配的KMP算法可以在O(n+m>的时间数量级上完成串的模式匹配操作。其改进过程在于:每当一趟匹配过程出现字符比较不相等时，不需回溯i指针，而是利用已经得到的部分匹配的结果将模式串向右滑动一段尽可能远的距离后，继续进行比较。滑动的这一段距离我们将会用到函数next[],
KMP算法的最大特点是指示主串的指针不须回溯，整个匹配过程中，对主串仅需从头到
尾扫描一遍，这对处理从外设输入的庞大文件很有效，可以边度入边匹配，而无需回头重读。
2、问题分析
2.1问题的分析和任务的定义
用C/C++编写一个程序实现模式匹配的KMP算法。要求在一个字符串中搜索某个子串，若搜索到就返回子串的位置；若未搜索到，就返回0。首先要输入个主串和模式串，先根据next( >函数求模式串的next值，利用KMP 算法进行匹配，再用输出函数输出结果！
2.2设计过程
本次课程设计利用模式匹配KMP算法实现串的相关操作：分别从键盘上任意输入三组字符串作为主串，在任意数取三组字符串作为模式串，利用《模式匹配KMP算法》依次使三组模式串与三组主串匹配，在使用《模式匹配KMP算法》时会调用到Getnext(>函数。
2.3逻辑设计
对该kmp 算法，定义的抽象数据类型如下：
ADT String{
数据对象：D={ai|ai∈CharacterSet,i=1,2,3,…,n,n≥0}
数据关系：R1={
基本操作：StrAssign(&T,chars>
初始条件：chars是字符串常量。
操作结果：生成一个其值等于chars的串T。
StrCopy 初始条件：串S存在。 操作结果：若S为空串，则返回TRUE，否则返回FALSE。 StrLength(S> 初始条件：串S存在。 操作结果：返回S元素的个数，成为串的长度。 Index(S,T,pos> 初始条件：串S和T存在，T是非空串，1≤pos≤StrLength(S>. 操作结果：若主串S中存在和串T相同的子串，则返回他在主串S中的第pos个字符之后第一次出现的位置；否则函数值为0。 DestoryString(&S> 初始条件：串S存在。 操作结果：串S被销毁。 }ADT String 该算法是对进行操作，对串的存储结构用—定长顺序存储表示：类似于现性表的顺序存储结构，用一组地址连续的存储单元存储串值得字符序列。在串的定长顺序存储结构中，按照与定义大小，为每个定义的串分配一个固定长度的存储区，则可用定长数组如下描述。 #define MAXSTRLEN 255 typedef unsigned char SString[MAXSTRLEN+1] 该算法分为五三个模块：第一模块[StrLength<）]<利用该函数求各串的长度）；第二模块[input( >函数]<利用该函数输入主串和模式串的值）；第三模块[get_next( >函数]<利用该函数求出模式串的next函数值）；第四模块[Index_KM<）函数]<利用该函数进行主串和模式串之间的匹配）；第五模块[output( >函数利用该函数输出匹配结果）。个模块之间的调用关系如下图所示：图4.1是对整个函数的流程图。图4.2是对KMP算法的流程图；图4.3是求next的函数值的流程图。 图2.1模块调用流程图 3、解决方案 3.1为主串和模式串赋值 分别定义三组字符串作为主串str1,str2,str3,利用cin函数依次为为三组字符串 赋值，从键盘上任意输入字符分别赋给str1 str2 str3,。以同样的方法模模式串p1,p2,p3赋值。 3.2求各串的长度 StrLength<）函数求的各串的长度，利用一个while循环语句，为后面的函数做好准备工作。 3.3求模式串的模式值next[]函数 用《模式匹配的KMP算法》当主串和模式串匹配不相等是，模式串应向右移动一段距离，此时我们需要得到模式串的next函数值。 如何求next函数，next函数值仅取决于模式本身而和主串无关。我们可以从分析next函数的定义出发用递推的方法求得next函数值。由定义知：next[1]=0设next[j]=k，即有：＂t1 t2 … tk-1 ＂ =＂tj-k+1 tj-k+2 … tj-1 next[j+1]=? 可能有两种情况：一种情况：若tk ＝tj 则表明在模式串中这就是说next[j+1]=k+1，即next[j＋１]=next[j]+1 第二种情况：若tk ≠tj 则表明在模式串中t1 t2 … tk ＂≠＂tj-k+1 tj-k+2 … tj ＂此时可把求next函数值的问题看成是一个模式匹配问题，整个模式串既是主串又是模式，而当前在匹配的过程中，已有(4.6>式成立，则当tk ≠tj 时应将模式向右滑动，使得第next[k]个字符和“主串”中的第j个字符相比较。若next[k]=k′，且t k′＝tj，则说明在主串中第j+1个字符之前存在一个最大长度为k′的子串，使得＂t1 t2 … t k′＂=＂tj-k′+1 tj- k′+2 … tj ＂此： next[j+1]=next[k]+1 同理若t k′≠tj，则将模式继续向右滑动至使第next[k′]个字符和tj 对齐，依此类推，直至tj 和模式中的某个字符匹配成功或者不存在任何 k′(1< k′ 综上所述，求next函数值过程的算法如下： void get _next(char t,int next[ ]> /*求模式t的next值并寸入next数组中*/ ｛int i=1,j=0。 next[0]=0。 while (i { while (j==0||t[i-1] = =t[j-1]> { ++i。++j。next[i-1]=j。}。 else j=next[j-1]。 } }//get_next 3.4模式匹配KMP算法的实现 KMP算法的思想：主串s，模式t希望某趟在si和tj匹配失败后，指针i不回溯，模式t向右“滑动”至某个位置上，使得tk 对准 s i 继续向右进行。显然，现在问题的关键是串t“滑动”到哪个位置上？不妨设位置为k，即si和tj匹配失败后，指针i不动，模式t向右“滑动”，使tk和si对准继续向右进行比较，要满足这一假设，就要有如下关系成立：＂t1 t2 ... tk-1 ＂ =＂si-k+1 si-k+2 (i) 1 ＂ (4.1>式左边是tk前面的k-1个字符，右边是si 前面的k-1个字符。而本趟匹配失败是在si和tj之处，已经得到的部分匹配结果是：＂t1 t 2 … tj-1 ＂ =＂si-j+1 si-j+2 …si-1 ＂<4.2）因为k 在求得模式的next函数之后，匹配可如下进行：假设以指针i和j分别指示主串和模式中的比较字符，令i的初值为pos，j的初值为1。若在匹配过程中si≠tj，则i和j分别增１，若si≠tj 匹配失败后，则i不变，j退到next[j]位置再比较，若相等，则指针各自增１，否则j再退到下一个next值的位置，依此类推。直至下列两种情况：一种是j退到某个next值时字符比较相等，则i和j分别增１继续进行匹配。另一种是j退到值为零<即模式的第一个字符失配），则此时i和j也要分别增１，表明从主串的下一个字符起和模式重新开始匹配。 KMP算法如下： int StrIndex_KMP(char *s,char *t,int pos> /*从串s的第pos个字符开始找首次与串t相等的子串*/ { int i=pos,j=-1,slen,tlen。 while (i<=s[0] && j<=t[0] > /*都没遇到结束符*/ if (j==-1||s==t[j]> { i++。 j++。 } else j=next[j]-1。 /*回溯*/ if (j>t[0]> return i-t[0]+1。/*匹配成功，返回存储位置*/ else return 0 } 4程序调试与测试 4.1若匹配成功：调试结果如下图所示 图4.1 匹配成功 4.2若匹配不成功：调试结果如下所示 图4.2 匹配不成功 4.3结果分析 利用该程序求模式串是否可以在主串中找到，先利用next( >函数求的模式串的next 函数值，利用for 循环语句分别输出next 函数值：<0，1，2，3，4）；<0，1，2，3）<0，1，1，2，2，3，1，2），再用KMP算法进行查找，若查找成功则输出模式串在主串中的位置:9 ,8, 9. 若没有找到则返回0；该调试结果与程序相对应； 对于模式匹配KMP算法时间复杂度为O 5 结束语 在这次课程设计中，我做的一个简单的模式匹配的kmp的算法，该算法是对一般算法的改进，kmp算法仅当模式与主串之间存在部分匹配时才比一般模式匹配算法快。其次该算法的最大特点是，指示主串的指针不需回溯，整个匹配过程中，对主串仅需要从头到尾扫描一遍，这时处理从外设输入的庞大文件有很大的效果，可以边输入边匹配，而无需回头读。 刚开始，对求子串的next[]值时，我仅对一串字符进行实例说明，经过自己和组员的讨论，我们共同研究才开始理解了该算法的应用，。让我们体验到了“过程是完美的”；正如一句话所说的，“我们可以错过一路风景，但不能错过终点站”我将之 改为“我可以不在乎结果，但我们永远记得过程最美”。一个好的程序=好结构+好结构，这次课设真让我体验到这句话。 当然，通过这次课程设计，我也发现了自身的很多不足之处，在以后的学习中，我会不断的完善自我，不断进取，能使自己在编程这方面有一个大的发展。在以后的工作中，我会弥补自己在设计方面的不足。在工作中，学会合作。其次，谢谢老师，学校给我提供的这次机会！ 参考文献 [1]严蔚敏吴伟民《数据结构》 [2] 王宏生宋继红《数据结构》北京.国防工业出版社.2006 [3] 彭波《数据结构教程》北京.清华出版社.2004 [4]谭浩强《c++程序设计》北京.清华大学出版社.2008 [5]陈杰《计算机专业课程设计中的需求分析[J]》集美大学学报.2009 [6]高一凡《数据结构算法实现及解读[M ]》西安.西安电子科技大学出版社. 2002 [7] 黄国瑜叶乃箐《数据结构》 附录： 程序清单 # include"iostream.h" # include "string" # include"stdlib.h" #define MaxStrLen 200 char s1[MaxStrLen],s2[MaxStrLen],s3[MaxStrLen],p1[20],p2[20],p3[20]。int next[20]。 int StrLength(char* s>。 void input(>。 int Index_KMP(char* s,char* t,int pos,int next[]>。 void get_next(char* s,int next[]>。 void output(>。 int StrLength(char* s> { int i,len。 i=0。len=0。 while(s[i]!='\0'> {len+=1。i++。} return len。 } void input(> { //利用该函数为串赋值。 cout<<"please input the main string of S1:\n"。 cin>>s1。 cout<<"please input the main string of S2:\n"。 cin>>s2。 cout<<"please input the main string of S3:\n"。 cin>>s3。 cout<<"please input the sub string of p1:\n"。 cin>>p1。 cout<<"please input the sub string of p2:\n"。 cin>>p2。 cout<<"please input the sub string of p3:\n"。 cin>>p3。 } int Index_KMP(char* s,char* t,int pos,int next[]> {//利用模式t的next函数求主串 s中的第pos个字符后的位置。 //串s和t采用定长顺序存储,且t非空,1<=pos<=strlent(s>-strlent(t>+1. int i,j,ls,lt。 i=pos-1,j=-1。//设置初值 ls=StrLength(s>。 //求主串s的长度 lt=StrLength(t>。//求模式串t的长度 while(i if(j==-1 || s[i]==t[j]> { //继续比较后继字符 i++。 j++。 } else { j=next[j]-1。 //模式串向右移 } } if (j>=lt> return i-lt+1。//匹配成功 else return 0。//匹配不成功 } void get_next(char* s,int next[]> { //求模式串的next函数值并存入数组next,为后面进行模式匹配做准备 int i,j。 i=1。 j=0。//设置初值 next[0]=0。 while (i { if (j==0 || s[i-1]==s[j-1]>//若j==0或s[i-1]=s[j-1],令next[i]=j+1. { i++。 j++。 next[i-1]=j。 } else j=next[j-1]。//若j!=0或s[i-1]!=s[j-1],令j=next[j-1] } cout<<"next="<<'\t'。 for (i=0。i cout< cout< } void output(> { cout<<"子串p1在主串s1的"< } void main(> { input(>。 get_next(p1,next>。 get_next(p2,next>。 get_next(p3,next>。 cout< 模式匹配的KMP算法详解 模式匹配的KMP算法详解 这种由D.E.Knuth,J.H.Morris和V.R.Pratt同时发现的改进的模式匹配算法简称为KMP算法。大概学过信息学的都知道，是个比较难理解的算法，今天特把它搞个彻彻底底明明白白。 注意到这是一个改进的算法，所以有必要把原来的模式匹配算法拿出来，其实理解的关键就在这里，一般的匹配算法： int Index(String S,String T,int pos)//参考《数据结构》中的程序 { i=pos;j=1;//这里的串的第1个元素下标是1 while(i<=S.Length && j<=T.Length) { if(S[i]==T[j]){++i;++j;} else{i=i-j+2;j=1;}//**************(1) } if(j>T.Length) return i-T.Length;//匹配成功 else return 0; } 匹配的过程非常清晰，关键是当‘失配’的时候程序是如何处理的？回溯，没错，注意到(1)句，为什么要回溯，看下面的例子： S:aaaaabababcaaa T:ababc aaaaabababcaaa ababc.(.表示前一个已经失配) 回溯的结果就是 aaaaabababcaaa a.(babc) 如果不回溯就是 aaaaabababcaaa aba.bc 这样就漏了一个可能匹配成功的情况 aaaaabababcaaa ababc 为什么会发生这样的情况？这是由T串本身的性质决定的，是因为T串本身有前后'部分匹配'的性质。如果T为abcdef这样的，大没有回溯的必要。 在前面的图文中，我们讲了“串”这种数据结构，其中有求“子串在主串中的位置”（字符串的模式匹配）这样的算法。解决这类问题，通常我们的方法是枚举从A串（主串）的什么位置起开始与B串（子串）匹配，然后验证是否匹配。假设A串长度为n，B串长度为m，那么这种方法的复杂度是O(m*n)的。虽然很多时候复杂度达不到m*n（验证时只看头一两个字母就发现不匹配了），但是我们有许多“最坏情况”，比如： A=“aaaaaaaaaaaaaaaaaaaaaaaaab”，B=“aaaaaaaab”。 大家可以忍受朴素模式匹配算法（前缀暴力匹配算法）的低效吗？也许可以，也许无所谓。 有三位前辈D.E.Knuth、J.H.Morris、V.R.Pratt发表一个模式匹配算法，最坏情况下是O(m+n)，可以大大避免重复遍历的情况，我们把它称之为克努特-莫里斯-普拉特算法，简称KMP算法。 假如，A=“abababaababacb”，B=“ababacb”，我们来看看KMP是怎样工作的。我们用两个指针i和j分别表示，。也就是说，i是不断增加的，随着i 的增加j相应地变化，且j满足以A[i]结尾的长度为j的字符串正好匹配B串的前j个字符（j当然越大越好），现在需要检验A[i+1]和B[j+1]的关系。 例子： S=“abcdefgab” T=“abcdex” 对于要匹配的子串T来说，“abcdex”首字符“a”与后面的串“bcdex”中任意一个字符都不相等。也就是说，既然“a”不与自己后面的子串中任何一字符相等，那么对于主串S来说，前5位字符分别相等，意味着子串T的首字符“a”不可能与S串的第2到第5位的字符相等。朴素算法步骤2,3,4,5的判断都是多余，下次的起始位置就是第6个字符。 例子： S=“abcabcabc” T=“abcabx” Brute Force(BF或蛮力搜索) 算法： 这是世界上最简单的算法了。 首先将匹配串和模式串左对齐，然后从左向右一个一个进行比较，如果不成功则模式串向右移动一个单位。 速度最慢。 那么，怎么改进呢？ 我们注意到Brute Force 算法是每次移动一个单位，一个一个单位移动显然太慢，是不是可以找到一些办法，让每次能够让模式串多移动一些位置呢？ 当然是可以的。 我们也注意到，Brute Force 是很不intelligent 的，每次匹配不成功的时候，前面匹配成功的信息都被当作废物丢弃了，当然，就如现在的变废为宝一样，我们也同样可以将前面匹配成功的信息利用起来，极大地减少计算机的处理时间，节省成本。^_^ 注意，蛮力搜索算法虽然速度慢，但其很通用，文章最后会有一些更多的关于蛮力搜索的信息。 KMP算法 首先介绍的就是KMP 算法。 这个算法实在是太有名了，大学上的算法课程除了最笨的Brute Force 算法，然后就介绍了KMP 算法。也难怪，呵呵。谁让Knuth D.E. 这么world famous 呢，不仅拿了图灵奖，而且还写出了计算机界的Bible 个人觉得这篇文章是网上的介绍有关KMP算法更让人容易理解的文章了，确实说得很“详细”，耐心地把它看完肯定会有所收获的～～，另外有关模式函数值next[i]确实有很多版本啊，在另外一些面向对象的算法描述书中也有失效函数f(j)的说法，其实是一个意思，即next[j]=f(j-1)+1，不过还是next[j]这种表示法好理解啊： KMP字符串模式匹配详解 KMP字符串模式匹配通俗点说就是一种在一个字符串中定位另一个串的高效算法。简单匹配算法的时间复杂度为O(m*n);KMP匹配算法。可以证明它的时间复杂度为O(m+n).。 一.简单匹配算法 先来看一个简单匹配算法的函数： int Index_BF ( char S [ ], char T [ ], int pos ) { /* 若串S 中从第pos(S 的下标0≤pos 实验四：KMP算法实验报告 一、问题描述 模式匹配两个串。 二、设计思想 这种由D.E.Knuth,J.H.Morris和V.R.Pratt同时发现的改进的模式匹配算法简称为KM P算法。 注意到这是一个改进的算法，所以有必要把原来的模式匹配算法拿出来，其实理解的关键就在这里，一般的匹配算法： int Index(String S,String T,int pos)//参考《数据结构》中的程序 { i=pos;j=1;//这里的串的第1个元素下标是1 while(i<=S.Length && j<=T.Length) { if(S[i]==T[j]){++i;++j;} else{i=i-j+2;j=1;}//**************(1) } if(j>T.Length) return i-T.Length;//匹配成功 else return 0; } 匹配的过程非常清晰，关键是当‘失配’的时候程序是如何处理的？为什么要回溯，看下面的例子： S:aaaaabababcaaa T:ababc aaaaabababcaaa ababc.(.表示前一个已经失配) 回溯的结果就是 aaaaabababcaaa a.(babc) 如果不回溯就是 aaaaabababcaaa aba.bc 这样就漏了一个可能匹配成功的情况 aaaaabababcaaa ababc 这是由T串本身的性质决定的，是因为T串本身有前后'部分匹配'的性质。如果T为a bcdef这样的，大没有回溯的必要。 改进的地方也就是这里，我们从T串本身出发，事先就找准了T自身前后部分匹配的位置，那就可以改进算法。 如果不用回溯，那T串下一个位置从哪里开始呢？ 还是上面那个例子，T为ababc，如果c失配，那就可以往前移到aba最后一个a的位置，像这样： 实验7、字符串查找 目的 掌握字符串模式匹配的经典算法。 问题描述 分别用简单方法和KMP方法实现index在文本串中查找指定字符串的功能。 步骤 1.定义字符串类型 2.实现简单的index操作，从文本串中查找指定字符串。 3.实现KMP方法的index操作，从文本串中查找指定字符串。 4.[选]建立一个文本文件，读入每一行来测试自己完成的练习，观察并理解程序的各 个处理。 设备和环境 PC计算机、Windows操作系统、C/C++开发环境 结论 能够理解和掌握字符串模式匹配的典型算法。 思考题 1.对KMP算法分别用手工和程序对某个模式串输出next和nextval。 朴素算法： #include #define ERROR -2 #define MAXLEN 100//字符串的最大长度 char S[MAXLEN+10],T[MAXLEN+10],st[MAXLEN+10];//串S和串T int S0,T0; //S0：串S的长度 T0：串T的长度 int pos; //pos的起始位置 void Init(char *S,int &S0)//读入字符串 { int len,i; New_Input: scanf("%s",st);//读入字符串 len=strlen(st); if (len>MAXLEN)//如果字符串的长度大于规定的字符串最大长度 { printf("This String is too long,Please Input a new one.nn"); goto New_Input;//重新读入字符串 实验题目：字符串的模式匹配 一、实验描述 用BF算法实现字符串的模式匹配 二、实验目的和任务 从主串的第pos位置字符开始和模式子串字符比较，如果相等，则继续逐个比较后续字符；否则从主串的下一个字符起再重新和模式子串的字符比较。直到找到匹配字符串或者是主串结尾。 三、概要设计 BF(Brute Force)算法是普通的模式匹配算法，BF算法的思想就是将目标串S的第一个字符与模式串P的第一个字符进行匹配，若相等，则继续比较S的第二个字符和P的第二个字符；若不相等，则比较S的第二个字符和P的第一个字符，依次比较下去，直到得出最后的匹配结果。 四、运行与测试 #include { char *szSource = "ababcababa"; char *szSub = "ababa"; int index =BFMatch(szSource, szSub); printf("目标串包含匹配串的起始位置：%d",index); } 五、运行结果 六、实验心得 通过这次课程设计，让我了解了字符串的定位操作即字符串模式匹配的基本概念和算法,探讨了字符串模式匹配操作的最基本的BF匹配算法。虽然看起来很简单的程序，做起来却遇到了不少问题，编程中出行了一些小错误，多次查改之后再进行修改，所以我觉得在以后的学习中，我会更加注重实践，注重多练，多积累。 对KMP算法的理解 整理者——戴红伟 字符匹配算法的现实意义：随着互联网的日渐庞大，信息也是越来越多，如何在海量的信息中快速查找自己所要的信息是网络搜索研究的热点所在，在这其中，字符串匹配算法起着非常重要的作用，一个高效的字符串匹配算法，可以极大的提高搜索的效率和质量。 （请同时参照课本P53～54相关内容） 1.要理解next[j]=k 中，k的含意； （1）BF算法 假设有字符串 S=S1S2......S N P=P1P2......P M 其中（M （2）KMP算法 为了解决上述的问题，KMP算法被发现。 KMP算法的思想如下。匹配过程中，出现不匹配时，S的指针不进行回朔（原地不动），将P尽可能地向后移动一定的距离，再进行匹配。 如图： （该图引用自互联网） 从上图中我们看到，当S移动到i，P到j的时候失配。这时候i不回朔，而只是将P 向前移动尽可能的距离，继续比较。 假设，P向右移动一定距离后，第k个字符P[k]和S[i]进行比较。 此时如上图，当P[j]和S[i]失配后，i不动，将P前移到K，让P[k]和S[i]继续匹配。现在的关键是K的值是多少？ 通过上图，我们发现，因为黄色部分表示已经匹配了的结果（因为是到了S[i]和P[j]的时候才失配，所以S i-j+1S i-j+2…S i-1 = P1P2…P j-1，见黄色的部分）。所以有： 1、S i-k+1S i-k+2…S i-1 = P j-k+1P j-k+2…P j-1。 所以当P前移到K时，有： 2、S i-k+1S i-k+2…S i-1 = P1P2…P k-1。 通过1，2有 P j-k+1P j-k+2…P j-1 = P1P2…P k-1。 呵呵，此时我们的任务就是求这个k值了。。。 参考：https://www.360docs.net/doc/d81481227.html,/2008-09/122068902261358.html 2.求出k 值 按照课本的求法就可以处理。 课本是已知前j个元素的“前缀函数值”，如何求的j+1个元素的前缀函数值。这里有一个思路要发生转变的地方，把一个模式串分成两个部分，因为我们要找k使得P j-k+1P j-k+2…P j-1= P1P2…P k-1，而这本身就是一个模式匹配问题，所以把模式串的前边部分的子串当作“新的模式串”，这样就很容易理解为什么当t k!=t j时，t1…t next[k]-1 = t j-（next[k]-1）…t j-1了。因为这时候t k匹配失败，需要进一步移动模式子串，所以移动的位置就是next[k]。 一、问题描述 模式匹配两个串。 二、设计思想 这种由D.E.Knuth,J.H.Morris和V.R.Pratt同时发现的改进的模式匹配算法简称为KM P算法。 注意到这是一个改进的算法，所以有必要把原来的模式匹配算法拿出来，其实理解的关键就在这里，一般的匹配算法： int Index(String S,String T,int pos)//参考《数据结构》中的程序 { i=pos;j=1;//这里的串的第1个元素下标是1 while(i<=S.Length && j<=T.Length) { if(S[i]==T[j]){++i;++j;} else{i=i-j+2;j=1;}//**************(1) } if(j>T.Length) return i-T.Length;//匹配成功 else return 0; } 匹配的过程非常清晰，关键是当‘失配’的时候程序是如何处理的？为什么要回溯，看下面的例子： S:aaaaabababcaaa T:ababc aaaaabababcaaa ababc.(.表示前一个已经失配) 回溯的结果就是 aaaaabababcaaa a.(babc) 如果不回溯就是 aaaaabababcaaa aba.bc 这样就漏了一个可能匹配成功的情况 aaaaabababcaaa ababc 这是由T串本身的性质决定的，是因为T串本身有前后'部分匹配'的性质。如果T为a bcdef这样的，大没有回溯的必要。 改进的地方也就是这里，我们从T串本身出发，事先就找准了T自身前后部分匹配的位置，那就可以改进算法。 如果不用回溯，那T串下一个位置从哪里开始呢？ 还是上面那个例子，T为ababc，如果c失配，那就可以往前移到aba最后一个a的位置，像这样： ...ababd... ababc ->ababc 这样i不用回溯，j跳到前2个位置，继续匹配的过程，这就是KMP算法所在。这个当T[j]失配后，j应该往前跳的值就是j的next值，它是由T串本身固有决定的，与S串无关。 《数据结构》上给了next值的定义： 0 如果j=1 next[j]={Max{k|1 入 侵 检 测 试 验 实验名称:_ KMP算法实验专业班级: _ 网络工程13-01 学号:_ 姓名: 一、问题描述 模式匹配两个串。 二、设计思想 这种由D.E.Knuth,J.H.Morris和V.R.Pratt同时发现的改进的模式匹配算法简称为KM P算法。 注意到这是一个改进的算法，所以有必要把原来的模式匹配算法拿出来，其实理解的关键就在这里，一般的匹配算法： int Index(String S,String T,int pos)//参考《数据结构》中的程序 { i=pos;j=1;//这里的串的第1个元素下标是1 while(i<=S.Length && j<=T.Length) { if(S[i]==T[j]){++i;++j;} else{i=i-j+2;j=1;}//**************(1) } if(j>T.Length) return i-T.Length;//匹配成功 else return 0; } 匹配的过程非常清晰，关键是当‘失配’的时候程序是如何处理的？为什么要回溯，看下面的例子： S:aaaaabababcaaa T:ababc aaaaabababcaaa ababc.(.表示前一个已经失配) 回溯的结果就是 aaaaabababcaaa a.(babc) 如果不回溯就是 aaaaabababcaaa aba.bc 这样就漏了一个可能匹配成功的情况 aaaaabababcaaa ababc 这是由T串本身的性质决定的，是因为T串本身有前后'部分匹配'的性质。如果T为a bcdef这样的，大没有回溯的必要。 改进的地方也就是这里，我们从T串本身出发，事先就找准了T自身前后部分匹配的位置，那就可以改进算法。 如果不用回溯，那T串下一个位置从哪里开始呢？ 还是上面那个例子，T为ababc，如果c失配，那就可以往前移到aba最后一个a的位置，像这样： ...ababd... ababc ->ababc 这样i不用回溯，j跳到前2个位置，继续匹配的过程，这就是KMP算法所在。这个当T[j]失配后，j应该往前跳的值就是j的next值，它是由T串本身固有决定的，与S串无关。 《数据结构》上给了next值的定义： 0 如果j=1 next[j]={Max{k|1 《KMP字符串模式匹配算法》教学课例 程玉胜 安庆师范学院计算机与信息学院 KMP字符串模式匹配是数据结构课程中一个重要的知识点，也是一个难点（学过KMP 算法的同学100％认为:KMP是数据结构课程中最难的部分）。为了消除他们对KMP算法学习的恐惧心理，激发他们的学习兴趣，调动其积极性，显得尤为重要。 基于以上，我们根据学生的认知特点和接受水平，对教材内容进行了重新构建，并按照数据结构中?时间复杂度?概念，增加了不同模式匹配算法的运行时间，动态逼真的显示了算法的?时间?性能，获得了较好的教学效果。 一、教学目标 知识目标：让学生了解KMP算法应用的普遍性。如：在目前众多的文字处理软件中得到广泛应用，如Microsoft Word中的?查找?或?替换?操作。而这种操作实现的机制，同学们特别是计算机专业的学生很少去想过。 能力目标：要求学生体验一个完整的抽象数据类型（ADT）的实现方法和过程，并学会判断、计算算法优劣的方法。 价值目标：消除恐怖的学习心态，让学生感悟数据结构算法实际应用价值，从而激发学习的兴趣，形成积极主动式学习的态度。 二、教材分析 使用教材是清华大学严蔚敏教授并由清华大学出版社出版的《数据结构（C语言版）》，该教材难度较大，其实验方法特别是ADT方法在教材中介绍较少，而且KMP算法更是从理论分析的角度介绍了匹配算法和next的计算，自学难度很大；虽然该节知识点属于?**（表示难度较大，可以不讲）?，但是其又是考研的一个热点，所以我们又不得不讲。 三、教学重点、难点 教学重点：KMP算法中的next和改进的nextval计算 教学难点：KMP算法中如何计算next值 四、教具准备 卡片：多个字符串，字符串指针 强力磁吸：6个 五、互动式教学过程 字符串匹配是计算机的基本任务之一。 举例来说，有一个字符串"BBC ABCDAB ABCDABCDABDE"，我想知道，里面是否包含另一个字符串"ABCDABD"？ 许多算法可以完成这个任务，Knuth-Morris-Pratt算法（简称KMP）是最常用的之一。它以三个发明者命名，起头的那个K就是著名科学家Donald Knuth。 我用自己的语言，试图写一篇比较好懂的KMP算法解释。 1. 首先，字符串"BBC ABCDAB ABCDABCDABDE"的第一个字符与搜索词"ABCDABD"的第一个字符，进行比较。因为B与A不匹配，所以搜索词后移一位。 2. 因为B与A不匹配，搜索词再往后移。 3. 就这样，直到字符串有一个字符，与搜索词的第一个字符相同为止。 4. 接着比较字符串和搜索词的下一个字符，还是相同。 5. 直到字符串有一个字符，与搜索词对应的字符不相同为止。 6. 这时，最自然的反应是，将搜索词整个后移一位，再从头逐个比较。这样做虽然可行，但是效率很差，因为你要把"搜索位置"移到已经比较过的位置，重比一遍。 7. 一个基本事实是，当空格与D不匹配时，你其实知道前面六个字符是"ABCDAB"。KMP算法的想法是，设法利用这个已知信息，不要把"搜索位置"移回已经比较过的位置，继续把它向后移，这样就提高了效率。 8. 怎么做到这一点呢？可以针对搜索词，算出一张《部分匹配表》（Partial Match Table）。这张表是如何产生的，后面再介绍，这里只要会用就可以了。 9. 已知空格与D不匹配时，前面六个字符"ABCDAB"是匹配的。查表可知，最后一个匹配字符B对应的"部分匹配值"为2，因此按照下面的公式算出向后移动的位数： KMP字符串模式匹配详解KMP字符串模式匹配通俗点说就是一种在一个字符串中定位另一个串的高效算法。简单匹配算法的时间复杂度为O(m*n);KMP匹配算法。可以证明它的时间复杂度为O(m+n).。 一.简单匹配算法 先来看一个简单匹配算法的函数： int Index_BF ( char S [ ], char T [ ], int pos ) { /* 若串S 中从第pos(S 的下标0≤pos 详解KMP算法中Next数组的求法 例如： 1 2 3 4 5 6 7 8 模式串 a b a a b c a c next值0 1 1 2 2 3 1 2 next数组的求解方法是：第一位的next值为0，第二位的next 值为1，后面求解每一位的next值时，根据前一位进行比较。首先将前一位与其next值对应的内容进行比较，如果相等，则该位的next 值就是前一位的next值加上1；如果不等，向前继续寻找next值对应的内容来与前一位进行比较，直到找到某个位上内容的next值对应的内容与前一位相等为止，则这个位对应的值加上1即为需求的next值；如果找到第一位都没有找到与前一位相等的内容，那么需求的位上的next值即为1。 看起来很令人费解，利用上面的例子具体运算一遍。 1.前两位必定为0和1。 2.计算第三位的时候，看第二位b的next值，为1，则把b和1对应的a进行比较，不同，则第三位a的next的值为1，因为一直比到最前一位，都没有发生比较相同的现象。 3.计算第四位的时候，看第三位a的next值，为1，则把a和1对应的a进行比较，相同，则第四位a的next的值为第三位a的next 值加上1。为2。因为是在第三位实现了其next值对应的值与第三位的值相同。 4.计算第五位的时候，看第四位a的next值，为2，则把a和2对应的b进行比较，不同，则再将b对应的next值1对应的a与第四位的a进行比较，相同，则第五位的next值为第二位b的next值加上1，为2。因为是在第二位实现了其next值对应的值与第四位的值相同。 5.计算第六位的时候，看第五位b的next值，为2，则把b和2对应的b进行比较，相同，则第六位c的next值为第五位b的next 值加上1，为3，因为是在第五位实现了其next值对应的值与第五位相同。 6.计算第七位的时候，看第六位c的next值，为3，则把c和3对应的a进行比较，不同，则再把第3位a的next值1对应的a与第六位c比较，仍然不同，则第七位的next值为1。 7.计算第八位的时候，看第七位a的next值，为1，则把a和1对应的a进行比较，相同，则第八位c的next值为第七位a的next 值加上1，为2，因为是在第七位和实现了其next值对应的值与第七位相同。 #define _CRT_SECURE_NO_DEPRECA TE #include s_i++; p_i++; continue; } else { if (p_i == 0) { s_i++; } else { p_i = next[p_i-1]; //取当前匹配不到之前的字符串的最大相等前缀的最后一个字符 } } for (i = 0; i < s_i - p_i; i++) { putchar(' '); } printf("%s\n",ptr); } return (p_i == plen) ? (s_i - plen) : -1;//返回第一次找到子串的下标位置 } int main() { char str[N] = { 0 }; char ptr[N] = { 0 }; int slen, plen; int next[N]; int ret; printf("请输入主串："); scanf("%s",str); printf("请输入模式串:"); scanf("%s",ptr); slen = strlen(str); plen = strlen(ptr); cal_next(ptr, next, plen); printf("\nnext:"); KMP算法是在最近这两年的软件设计师考试中才出现的。2次都是让求Next函数的序列（其实是）。先看看题吧。 （2011年下半年上午题） （2012年上半年上午题） 其实做这个题很简单，我先说说这个题里的各种概念。 给定的字符串叫做模式串T。j表示next函数的参数，其值是从1到n。而k则表示一种情况下的next函数值。p表示其中的某个字符，下标从1开始。看等式左右对应的字符是否相等。 好了，开始做题了。 首先，要把字符串填入到一个表格中：（拿第一个题为例） 将j导入next函数，即可求得， j=1时，next[0]=0； j=2时，k的取值为(1,j)的开区间，所以整数k是不存在的，那就是第三种情况，next[2]=1； j=3时，k的取值为（1，3）的开区间，k从最大的开始取值，然后带入含p的式子中验证等式是否成立，不成立k取第二大的值。现在是k=2，将k导入p的式子中得，p1=p2，即“a”=“b”，显然不成立， 舍去。k再取值就超出范围了，所以next[3]不属于第二种情况，那就是第三种了，即next[3]=1； j=4时，k的取值为（1，4）的开区间，先取k=3，将k导入p的式子中得，p1p2=p2p3，不成立。再取k=2，得p1=p3，成立。所以next[4]=2； j=5时，k的取值为（1，5）的开区间，先取k=4，将k导入p的式子中得，p1p2p3=p2p3p4，不成立。再取k=2，得p1p2=p3p4，不成立。再取k=2，得p1=p4，成立。所以next[4]=2； j=6时，k的取值为（1，6）的开区间，先取k=5，将k导入p的式子中得，p1p2p3p4=p2p3p4p5，不成立。取k=4，得p1p2p3=p3p4p5，不成立。再取k=3，将k导入p的式子中得，p1p2=p4p5，成立。所以next[4]=3； j=7时，k的取值为（1，7）的开区间，先取k=6，将k导入p的式子中得，p1p2p3p4p5=p2p3p4p5p6，不成立。再取k=5，得 p1p2p3p4=p3p4p5p6 ，不成立。再取k=4，得p1p2p3=p4p5p6 ，成立。所以next[4]=4； KMP中next数组以及nextval数组的求法。明确传统模式匹配算法的不足,明确next数组需要改进之外。其中,理解算法是核心,会求数组是得分点。不用我多说,这一节内容是本章的重中之重。可能进行的考查方式是:求next和nextval 数组值,根据求得的。 KMP算法即Knuth-Morris-Pratt算法，是模式匹配的一种改进算法，因为是名字中三人同时发现的，所以称为KMP算法。因为偶然接触到有关KMP的问题，所以上网查了一下next数组和nextval数组的求法，却没有找到，只有在CSDN 的资料文件里找到了next数组的简单求法（根据书上提供的程序也可以求到，但一般在课堂讲解的时候，学生难以理解，所以希望以更容易理解的形式来讲解），那位高人说时间关系，先讲到这里，于是讲完了next数组就功成身退了。BS的同时，自己研究了下nextwal数组，发现了其中的简易规律，并写了出来，希望能对需要快速理解KMP中nextval的求法的朋友有所帮助。 int get_nextval(SString T,int &nextval[ ]){ //求模式串T的next函数修正值并存入数组nextval。 i=1; nextval[1]=0; j=0; while(i 改进的模式匹配算法的理论分析 设 T = t0 t1 … t s-1 t s t s+1 t s+2 … t s+j-1 t s+j t s+j+1 … t n-1 P = p0 p1 p2 … p j-1 p m-1． 若在匹配过程中出现了如下情况： t s t s+1t s+2… t s+j-1= p0p1p2… p j-1，(1)但t s+j ≠ p j．也就是说，在匹配过程出现了： T t0 t1 … t s-1t s t s+1t s+2… t s+j-1t s+j t s+j+1… t s+m-1 … t n-1 ‖ ‖ ‖ … ‖ ? P p0p1p2 … p j-1p j p j-1… p m-1 则本次匹配失败． 由朴素的模式匹配算法，我们需要下一趟匹配，即需要验证下式是否成立： t s+1t s+2… t s+j-1 t s+j … t s+m?= p0p1 … p j-2p j-1… p m-1(2)如果（2）式成立，则匹配成功，返回s+1；否则需要再下一趟的匹配：t s+2t s+3… t s+j-1t s+j… t s+m+1?= p0p1… p j-3p j-2 …p m-1 (2')以此类推． 下面给出两个互逆的条件 p0p1… p j-2 = p1p2 …p j-1 (3) p0p1… p j-2 ≠p1p2 …p j-1 (3')显然，这两个条件能且只能满足一个．下面并分情况讨论：【1】如果(3) 式成立，则由(1) (2) (3) 式，可以断定p0 p1 …p j-2 = t s+1 t s+2 … t s+j-1成立，即在（3）式条件下，对(2) 式的验证只需要从p j- 引记 此前一天，一位MS的朋友邀我一起去与他讨论快速排序，红黑树，字典树，B树、后缀树，包括KMP算法，唯独在讲解KMP算法的时候，言语磕磕碰碰，我想，原因有二：1、博客内的东西不常回顾，忘了不少；2、便是我对KMP算法的理解还不够彻底，自不用说讲解自如，运用自如了。所以，特再写本篇文章。由于此前，个人已经写过关于KMP算法的两篇文章，所以，本文名为：KMP算法之总结篇。 本文分为如下六个部分： 1. 第一部分、再次回顾普通的BF算法与KMP算法各自的时间复杂度，并两相对照各 自的匹配原理； 2. 第二部分、通过我此前第二篇文章的引用，用图从头到尾详细阐述KMP算法中的 next数组求法，并运用求得的next数组写出KMP算法的源码； 3. 第三部分、KMP算法的两种实现，代码实现一是根据本人关于KMP算法的第二篇文 章所写，代码实现二是根据本人的关于KMP算法的第一篇文章所写； 4. 第四部分、测试，分别对第三部分的两种实现中next数组的求法进行测试，挖掘其 区别之所在； 5. 第五部分、KMP完整准确源码，给出KMP算法的准确的完整源码； 6. 第六步份、一眼看出字符串的next数组各值，通过几个例子，让读者能根据字符串 本身一眼判断出其next数组各值。 力求让此文彻底让读者洞穿此KMP算法，所有原理，来龙去脉，让读者搞个通通透透（注意，本文中第二部分及第三部分的代码实现一的字符串下标i 从0开始计算，其它部分如第三部分的代码实现二，第五部分，和第六部分的字符串下标i 皆是从1开始的）。 在看本文之前，你心中如若对前缀和后缀这个两个概念有自己的理解，便最好了。有些东西比如此KMP算法需要我们反复思考，反复求解才行。个人写的关于KMP算法的第二篇文章为：六（续）、从KMP算法一步一步谈到BM算法；第一篇为：六、教你初步了解KMP算法、updated（文末链接）。ok，若有任何问题，恳请不吝指正。多谢。 第一部分、KMP算法初解 1、普通字符串匹配BF算法与KMP算法的时间复杂度比较 这里有两种KMP算法的详解~大家可以参考 KMP字符串模式匹配详解KMP字符串模式匹配通俗点说就是一种在一个字符串中定位另一个串的高效算法。简单匹配算法的时间复杂度为O(m*n);KMP匹配算法。可以证明它的时间复杂度为O(m+n).。 一．简单匹配算法 先来看一个简单匹配算法的函数： int Index_BF ( char S [ ], char T [ ], int pos ) { /* 若串S 中从第pos(S 的下标0≤pos j=0 起比较S[i+j] 与T[j]，若相等，则在主串S 中存在以i 为起始位置匹配成功的可能性，继续往后比较( j逐步增1 )，直至与T串中最后一个字符相等为止，否则改从S串的下一个字符起重新开始进行下一轮的"匹配"，即将串T向后滑动一位，即i 增1，而j 退回至0，重新开始新一轮的匹配。 例如：在串S=”abcabcabdabba”中查找T=” abcabd”（我们可以假设从下标0开始）:先是比较S[0]和T[0]是否相等，然后比较S[1] 和T[1]是否相等…我们发现一直比较到S[5] 和T[5]才不等。如图： 当这样一个失配发生时，T下标必须回溯到开始，S下标回溯的长度与T相同，然后S 下标增1,然后再次比较。如图： 这次立刻发生了失配，T下标又回溯到开始，S下标增1,然后再次比较。如图： 这次立刻发生了失配，T下标又回溯到开始，S下标增1,然后再次比较。如图：模式匹配的KMP算法详解
字符串的模式匹配算法
字符串匹配算法总结
KMP字符串模式匹配算法解释
模式匹配KMP算法实验报告
字符串模式匹配
字符串的模式匹配实验报告
KMP算法-如何理解
模式匹配KMP算法实验步骤
KMP算法实验
《KMP 字符串模式匹配算法》教学课例
字符串匹配的KMP算法
(完整word版)KMP算法详解
详解KMP算法中Next数组的求法
KMP算法源码
KMP算法考题
KMP算法演算过程(讲述内容)
KMP算法的理论推导
kmp算法详解
大学课件-KMP算法