KMP算法文献综述
数据结构——KMP算法
数据结构——KMP算法算法介绍 KMP算法是⼀种改进的字符串匹配算法，由D.E.Knuth，J.H.Morris和V.R.Pratt提出的，因此⼈们称它为克努特—莫⾥斯—普拉特操作（简称KMP算法）。
KMP算法的核⼼是利⽤匹配失败后的信息，尽量减少模式串与主串的匹配次数以达到快速匹配的⽬的。
具体实现就是通过⼀个next()函数实现，函数本⾝包含了模式串的局部匹配信息。
KMP算法的时间复杂度O(m+n)。
next数组 我们记主串为字符串S，模式串为字符串P。
我们⽤next[j]表⽰以字符Pj结尾的⼦串的长度相等的前缀字符串与后缀字符串长度的最⼤值。
特别地，当没有满⾜条件的⼦串时，next[j] = 0。
为了⽅便起见，我们将字符串从下标1开始匹配。
如此，next数组所表⽰的长度就与下标数值相等了。
算法思路 我们从左到右依次枚举S的每⼀个字符Si，对于当前待匹配字符Si，我们假设当前P字符串中已匹配到Pj。
那么我们只需判断Si和Pj+1，若两者相同，则继续匹配。
若两者不相同，那么我们使j=next[j]，即可最⼤限度的减少匹配次数。
因为S字符串的从某位置开始到前i-1的部分与P字符串的前j个字符已匹配(即完全相同)，如图中两蓝⾊直线所夹的S、P的两段，⽽P1到Pnext[j]部分是长度最⼤的与以Pj结尾的后缀完全相同的前缀（图中绿⾊线段），⽽该以Pj结尾的后缀则必定与S中⼀段以Si-1结尾的⼦串完全相同，因⽽保证了上述操作的正确性。
接下去只需重复上述操作即可。
⽽对于next数组的预处理，也同上述操作类似，我们只需要以字符串P来匹配字符串P即可。
模板呈现 模板题链接： 代码如下：#include <iostream>#include <algorithm>#include <cstdio>using namespace std;const int M = 1e5+10;int n,m;int ne[M];char s[M],p[M];int main(){cin>>n>>p+1;cin>>m>>s+1;for(int i=2,j=0;i<=n;i++){while(j && p[i]!=p[j+1])j=ne[j];if(p[i]==p[j+1])j++;ne[i]=j;}for(int i=1,j=0;i<=m;i++){while(j && s[i]!=p[j+1])j=ne[j];if(s[i]==p[j+1])j++;if(j==n){printf("%d ",i-n+1-1);j=ne[j]; //可有可⽆，好习惯要加上。
KMP算法详解范文
KMP算法详解范文KMP算法（Knuth-Morris-Pratt算法）是一种经典的字符串匹配算法，用于在文本中查找一个模式串（pattern）的出现位置。
相对于朴素的字符串匹配算法，KMP算法具有更高的效率，特别是在处理大量数据时。
KMP算法的核心思想是利用已经匹配过的信息来避免不必要的回溯。
朴素的字符串匹配算法是一种从文本的每一位字符开始与模式串进行比较的方法，当匹配失败时，会进行回溯，然后再继续从下一位字符开始匹配。
这样的回溯操作会导致算法的效率降低。
KMP算法通过构造一个部分匹配表（partial match table）来实现。
部分匹配表是一个数组，用于记录模式串中每个位置的最长匹配前缀的长度。
具体来说，部分匹配表中的每个元素记录的是对应位置前缀的最长相等前后缀的长度。
例如，假设模式串为"ABCDABD"，部分匹配表的内容如下：位置0123456模式串ABCDABD部分匹配值0000120部分匹配表的构造过程是通过逐个字符的比较来完成的。
具体的步骤如下：1.第一个位置的部分匹配值设为0；2.从第二个位置开始，如果模式串中当前位置的字符与前面位置的字符相等，则部分匹配值为前一个位置的部分匹配值加1；3.如果模式串中当前位置的字符与前面位置的字符不相等，则需要找到前一个位置的最长匹配前后缀，并将当前位置的部分匹配值更新为最长匹配前后缀的长度。
这是通过比较当前位置字符与前一个位置的最长匹配前后缀的下一个字符来实现的，直到找到最长匹配前后缀或者无法再找到为止。
利用部分匹配表，KMP算法可以在匹配过程中避免进行不必要的回溯。
具体的匹配过程如下：1.设置文本串的索引i和模式串的索引j，两者都从0开始；2.对比文本串的第i位和模式串的第j位进行字符比较；3.如果匹配成功，将i和j都加1；4.如果不匹配，则利用部分匹配表来确定模式串的下一个比较位置。
具体来说，如果j大于0，则将j更新为部分匹配表中j-1位置的部分匹配值，然后再与i进行比较；如果j等于0，则将i加15.重复步骤2到步骤4，直到模式串匹配成功或者遍历完文本串。
kmp算法报告
KMP算法报告●算法思想KMP算法是基于BF算法的低效率进行改进的，因此在介绍KMP算法之前先让我们来了解BF算法。
BF的思想是直截了当的：将主串S中某个位置i起始的子串和模式串T相比较。
即从j=0 起比较S[i+j] 与T[j]，若相等，则在主串S 中存在以i 为起始位置匹配成功的可能性，继续往后比较( j逐步增1 )，直至与T串中最后一个字符相等为止，否则改从S串的下一个字符起重新开始进行下一轮的"匹配"，即将串T向后滑动一位，即i 增1，而j 退回至0，重新开始新一轮的匹配。
KMP算法先根据已经部分匹配的信息，将匹配的指针跳过不必匹配的位置。
在KMP算法中，对于每一个模式串我们会事先计算出模式串的内部匹配信息，在匹配失败时最大的移动模式串，以减少匹配次数。
比如，在简单的一次匹配失败后，我们会想将模式串尽量的右移和主串进行匹配。
右移的距离在KMP算法中是如此计算的：在已经匹配的模式串子串中，找出最长的相同的前缀和后缀，然后移动使它们重叠。
●算法步骤Step1:分别指示主串、模式串比较位置的指针i,j 初始化。
Step2:重复下列操作，直至S中所剩字符个数小于T的长度或T中所有字符均比较完。
2.1 如果si=tj, i和j 分别增一；否则；2.2 j=next[j]2.3 如果 j=0,则将i 和j 分别加一。
Step3：如果T中所有字符均比较完，则反回匹配的起始下标；否则，返回-1.●算法实现#include <iostream>#include <cstring>using namespace std;void getNext(const char* pattern,int next[]){next[0]= -1;int k=-1,j=0;while(pattern[j] != '\0'){if(k!= -1 && pattern[k]!= pattern[j] )k=next[k];++j;++k;if(pattern[k]== pattern[j])next[j]=next[k];elsenext[j]=k;}//这里是我加的显示部分// for(int i=0;i<j;i++)//{// cout<<next[i];//}//cout<<endl;}int KMP(const char *Text,const char* Pattern)//const 表示函数内部不会改变这个参数的值。
KMP算法详解
KMP算法详解KMP 算法详解KMP 算法是⼀个⼗分⾼效的字符串查找算法，⽬的是在⼀个字符串 s 中，查询 s 是否包含⼦字符串 p，若包含，则返回 p 在 s 中起点的下标。
KMP 算法全称为 Knuth-Morris-Pratt 算法，由 Knuth 和 Pratt 在1974年构思，同年 Morris 也独⽴地设计出该算法，最终由三⼈于1977年联合发表。
举⼀个简单的例⼦，在字符串 s = ababcabababca 中查找⼦字符串 p = abababca，如果暴⼒查找，我们会遍历 s 中的每⼀个字符，若 s[i] = p[0]，则向后查询p.length() 位是否都相等。
这种朴素的暴⼒的算法复杂度为O(m×n)，其中m和n分别是 p 和 s 的长度。
KMP 算法可以⽅便地简化这⼀查询的时间复杂度，达到O(m+n)。
1. PMT 序列PMT 序列是 KMP 算法的核⼼，即 Partial Match Table（部分匹配表）。
举个例⼦：char a b a b a b c aindex01234567PMT00123401PMT 的值是字符串的前缀集合与后缀集合的交集中最长元素的长度。
PMT[0] = 0: 字符串 a 既没有前缀，也没有后缀；PMT[1] = 0: 字符串 ab 前缀集合为 {a}，后缀集合为 {b}，没有交集；PMT[2] = 1: 字符串 aba 前缀集合为 {a, ab}，后缀集合为 {ba, a}，交集为 {a}，交集元素的最长长度为1；PMT[3] = 2: 字符串 abab 前缀集合为 {a, ab, aba}，后缀集合为 {bab, ab, b}，交集为 {ab}，交集元素的最长长度为2；…… 以此类推。
2. 算法主体现在我们已经知道了 PMT 序列的含义，那么假设在 PMT 序列已经给定的情况下，如何加速字符串匹配算法？tar 存储 s 的下标，从 0 开始，若 tar > s.length() - 1，代表匹配失败；pos 存储 p 的下标，从 0 开始，若 s[tar] != p[pos]，则 pos ⾛到下⼀个可能匹配的位置。
KMP算法
KMP算法，是由Knuth，Morris，Pratt共同提出的模式匹配算法，其对于任何模式和目标序列，都可以在线性时间内完成匹配查找，而不会发生退化，是一个非常优秀的模式匹配算法。
但是相较于其他模式匹配算法，该算法晦涩难懂，第一次接触该算法的读者往往会看得一头雾水，主要原因是KMP算法在构造跳转表next过程中进行了多个层面的优化和抽象，使得KMP算法进行模式匹配的原理显得不那么直白。
本文希望能够深入KMP算法，将该算法的各个细节彻底讲透，扫除读者对该算法的困扰。
KMP算法对于朴素匹配算法的改进是引入了一个跳转表next[]。
以模式字符串abcabcacab为例，其跳转表为：举例说明，如下是使用上例的模式串对目标串执行匹配的步骤next跳转表，在进行模式匹配，实现模式串向后移动的过程中，发挥了重要作用。
这个表看似神奇，实际从原理上讲并不复杂，对于模式串而言，其前缀字符串，有可能也是模式串中的非前缀子串，这个问题我称之为前缀包含问题。
以模式串abcabcacab为例，其前缀4 abca，正好也是模式串的一个子串abc(abca)cab，所以当目标串与模式串执行匹配的过程中，如果直到第8个字符才匹配失败，同时也意味着目标串当前字符之前的4个字符，与模式串的前4个字符是相同的，所以当模式串向后移动的时候，可以直接将模式串的第5个字符与当前字符对齐，执行比较，这样就实现了模式串一次性向前跳跃多个字符。
所以next表的关键就是解决模式串的前缀包含。
当然为了保证程序的正确性，对于next表的值，还有一些限制条件，后面会逐一说明。
如何以较小的代价计算KMP算法中所用到的跳转表next，是算法的核心问题。
这里我们引入一个概念f(j)，其含义是，对于模式串的第j个字符pattern[j]，f(j)是所有满足使pattern[1...k-1] = pattern[j-(k-1)...j - 1](k < j)成立的k的最大值。
KMP算法解析范文
KMP算法解析范文KMP算法的核心是构建一个部分匹配表（Partial Match Table），用来记录已匹配字符串的前缀和后缀的最长公共部分。
这样，在匹配过程中，当出现不匹配的字符时，就可以利用部分匹配表的信息来调整匹配的位置，而不是回溯所有已匹配的字符。
为了方便理解KMP算法的原理，我们首先从部分匹配表的构建开始。
假设待匹配的字符串为P，原字符串为T。
1.部分匹配表的定义：部分匹配表是一个长度为P.length的数组，记为next[]，其中next[i]表示长度为i的前缀子串（不包含最后一个字符）和后缀子串（不包含第一个字符）的最长公共部分的长度。
2.部分匹配表的构建：首先，next[0]被定义为-1，next[1]被定义为0。
然后，从i=2开始，依次计算next[i]的值。
（1）假设next[i-1]的值已经求得，即长度为i-1的前缀子串和后缀子串的最长公共部分的长度为next[i-1]。
（2）将P的前缀子串P[0:i-1]和后缀子串P[1:i-1]的长度都加1，得到长度为i的前缀子串和后缀子串。
分别记为P[0:i]和P[1:i]。
（3）比较P[0:i]和P[1:i]，找到最长的公共部分。
如果存在公共部分，则next[i]取公共部分的长度；否则，next[i]取0。
其中，比较的方法是利用已经求得的next[i-1]和P[i-1]来确定比较的位置。
具体而言，如果P[i-1]与P[next[i-1]]相等，则next[i]等于next[i-1]加1；否则，需要继续往前寻找可能的公共部分，即比较P[i-1]和P[next[next[i-1]]]，直到找到公共部分或者找到P的开头。
3.KMP算法的匹配过程：假设待匹配的字符串为P，原字符串为T，分别用变量i和j表示匹配过程中的位置。
（1）初始化i=0和j=0。
（2）比较P[i]和T[j]。
如果相等，则继续比较下一个字符；如果不相等，则根据部分匹配表调整i和j的值。
动态规划之KMP算法详解
动态规划之KMP算法详解KMP 算法（Knuth-Morris-Pratt 算法）是一个著名的字符串匹配算法，效率很高，但是确实有点复杂。
很多读者抱怨 KMP 算法无法理解，这很正常，想到大学教材上关于KMP 算法的讲解，也不知道有多少未来的Knuth、Morris、Pratt 被提前劝退了。
有一些优秀的同学通过手推 KMP 算法的过程来辅助理解该算法，这是一种办法，不过本文要从逻辑层面帮助读者理解算法的原理。
十行代码之间，KMP 灰飞烟灭。
先在开头约定，本文用pat表示模式串，长度为M，txt表示文本串，长度为N。
KMP 算法是在txt中查找子串pat，如果存在，返回这个子串的起始索引，否则返回 -1。
为什么我认为 KMP 算法就是个动态规划问题呢，等会有解释。
对于动态规划，之前多次强调了要明确dp数组的含义，而且同一个问题可能有不止一种定义dp数组含义的方法，不同的定义会有不同的解法。
读者见过的 KMP 算法应该是，一波诡异的操作处理pat后形成一个一维的数组next，然后根据这个数组经过又一波复杂操作去匹配txt。
时间复杂度 O(N)，空间复杂度 O(M)。
其实它这个next数组就相当于dp数组，其中元素的含义跟pat的前缀和后缀有关，判定规则比较复杂，不太好理解。
本文则用一个二维的dp数组（但空间复杂度还是O(M)），重新定义其中元素的含义，使得代码长度大大减少，可解释性大大提高。
PS：本文的代码参考《算法4》，原代码使用的数组名称是dfa （确定有限状态机），因为我们的公众号之前有一系列动态规划的文章，就不说这么高大上的名词了，本文还是沿用dp数组的名称。
一、KMP 算法概述首先还是简单介绍一下 KMP 算法和暴力匹配算法的不同在哪里，难点在哪里，和动态规划有啥关系。
暴力的字符串匹配算法很容易写，看一下它的运行逻辑：// 暴力匹配（伪码）int search(String pat, String txt) {int M = pat.length;int N = txt.length;for (int i = 0; i < N - M; i++) {int j;for (j = 0; j < M; j++) {if (pat[j] != txt[i+j])break;}// pat 全都匹配了if (j == M) return i;}// txt 中不存在 pat 子串return -1;}对于暴力算法，如果出现不匹配字符，同时回退txt和pat的指针，嵌套 for 循环，时间复杂度 O(MN)，空间复杂度O(1)。
kmp百度百科
kmp算法[编辑本段]kmp算法-概述一种改进的字符串匹配算法，由 D.E.Knuth与V.R.Pratt和J.H.Morris同时发现，因此人们称它为克努特——莫里斯——普拉特操作（简称KMP算法）。
[编辑本段]kmp算法-学习介绍完全掌握KMP算法思想学过数据结构的人，都对KMP算法印象颇深。
尤其是新手，更是难以理解其涵义，搞得一头雾水。
今天我们就来面对它，不将它彻底搞懂，誓不罢休。
如今，大伙基本上都用严蔚敏老师的书，那我就以此来讲解KMP 算法。
(小弟正在备战考研，为了节省时间，很多课本上的话我都在此省略了，以后一定补上。
)严老的《数据结构》79页讲了基本的匹配方法，这是基础。
先把这个搞懂了。
80页在讲KMP算法的开始先举了个例子，让我们对KMP的基本思想有了最初的认识。
目的在于指出“由此，在整个匹配的过程中，i指针没有回溯，”。
我们继续往下看：现在讨论一般情况。
假设主串：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)’= ’s(j-k+1)s(j-k+2)……s(j-1)’接下来看“反之，若模式串中存在满足式(4-4)。
KMP模式匹配算法的研究分析
进行计算 , 结果表明 , 改进后的 K M P 算法 和 KM P 算法的时间复杂度均为 O( m + n) , 但改进后 算法的平均 比较次数约 为未 改进算法的平均比较次数的 0. 833 倍 , 因此改进后的 KM P 算法更能提高字符串模式匹配的工作效率。 关键词 模式匹配 ; K M P 算法 ; 算法 ; nex t 函数 T P301 中图分类号
Research and Analysis of KMP Pattern Matching Algorithm
Ya ng Z hanha i ( Comput er Center , Y an an U nv ersity , Y an an 716000)
Abstract
T his paper analyzes an improv ed metho d of K M P algo rit hm and calculat es the complex ity of the alg or ithm
法中的 i 不是保持不变 , 而是增加了, 这就意味着 加快了模式匹配的进度。 4. 2 算法的分析 KM P 算法时 间复杂度 可分两 部分来 进行分 析 , 一部分是扫描算法中 T [ i ] 与 P[ j ] 的比较次数 , 另一部分是根据模式来计算 nex t [ j ] 的工作量。计 算 nex t [ j ] 与模 P 的长度 m 有关, 与主串无关 , 其 算法时间复杂度为 O( m) 。因为 KM P 算法与改进 的 KM P 算法涉及的计算 nex t [ j ] 的工作量相同 , 所以这两个算法的时间复杂度主要区别在是否有 # i f ( i+ j - k m& & P [ j ] ! = T [ i+ j - k] ) i = i+ j - k; ∃ 这句上, 设 p ( m, n) 与 q ( m, n) 分别为 KM P 算法和改进 KM P 算法中 T [ i] 与 P[ j ] 的平均比较 次数, 则考虑到: if 语句的两个分支出现的概率相等 , 平均出现 次数为 n/ 2; else 分支语句取得 n/ 2 个 nex t[ j ] 后, i 不得增 加却又投入了比较 , 使得在同一个 i 位置上增加了 一次比较, 因此: p ( m, n) = n + n/ 2+ m = 1. 5n+ m 。 在改进的 KMP 算法中的语句# i f ( i + j - k n& & P[ j ] ! = T [ i + j - k] ) i= i + j - k; ∃ 的平均 出现次数为 n/ 2, 该分支语句使得 i 向右# 滑动∃ 的 机会增加了 n/ 4 次, 这些机会不是使 i 保持不变 , 而是使 i 朝着匹配处前进了亦即促进了模式匹配 的进度 , 因此 : q( m, n) = 1. 5 n- n/ 4+ m = 1 . 25n + m 令 m 为恒定值 , 故而 q( m, n) 1 . 25n + m = lim = 0. 833 p ( m, n) n % & 1. 5 n+ m 可见, p ( m, n) 与 q( m, n) 同阶 , 它们的时间复
KMP算法
从头到尾彻底理解KMP作者：July时间：最初写于2011年12月，2014年7月21日晚10点全部删除重写成此文，随后的半个多月不断反复改进。
后收录于新书《编程之法：面试和算法心得》第4.4节中。
1. 引言本KMP原文最初写于2年多前的2011年12月，因当时初次接触KMP，思路混乱导致写也写得混乱。
所以一直想找机会重新写下KMP，但苦于一直以来对KMP的理解始终不够，故才迟迟没有修改本文。
然近期因开了个算法班，班上专门讲解数据结构、面试、算法，才再次仔细回顾了这个KMP，在综合了一些网友的理解、以及算法班的两位讲师朋友曹博、邹博的理解之后，写了9张PPT，发在微博上。
随后，一不做二不休，索性将PPT 上的内容整理到了本文之中（后来文章越写越完整，所含内容早已不再是九张PPT 那样简单了）。
KMP本身不复杂，但网上绝大部分的文章（包括本文的2011年版本）把它讲混乱了。
下面，咱们从暴力匹配算法讲起，随后阐述KMP的流程步骤、next 数组的简单求解递推原理代码求解，接着基于next 数组匹配，谈到有限状态自动机，next 数组的优化，KMP的时间复杂度分析，最后简要介绍两个KMP的扩展算法。
全文力图给你一个最为完整最为清晰的KMP，希望更多的人不再被KMP折磨或纠缠，不再被一些混乱的文章所混乱。
有何疑问，欢迎随时留言评论，thanks。
2. 暴力匹配算法假设现在我们面临这样一个问题：有一个文本串S，和一个模式串P，现在要查找P在S中的位置，怎么查找呢？如果用暴力匹配的思路，并假设现在文本串S匹配到 i 位置，模式串P 匹配到 j 位置，则有：如果当前字符匹配成功（即S[i] == P[j]），则i++，j++，继续匹配下一个字符；如果失配（即S[i]! = P[j]），令i = i - (j - 1)，j = 0。
相当于每次匹配失败时，i 回溯，j 被置为0。
理清楚了暴力匹配算法的流程及内在的逻辑，咱们可以写出暴力匹配的代码，如下：[cpp]view plaincopyprint?1.int ViolentMatch(char* s, char* p)2.{3.int sLen = strlen(s);4.int pLen = strlen(p);5.6.int i = 0;7.int j = 0;8.while (i < sLen && j < pLen)9.{10. if (s[i] == p[j])11. {12. //①如果当前字符匹配成功（即S[i] == P[j]），则i++，j++13. i++;14. j++;15. }16. else17. {18. //②如果失配（即S[i]! = P[j]），令i = i - (j - 1)，j = 019. i = i - j + 1;20. j = 0;21. }22. }23. //匹配成功，返回模式串p在文本串s中的位置，否则返回-124. if (j == pLen)25. return i - j;26. else27. return -1;28.}举个例子，如果给定文本串S“BBC ABCDAB ABCDABCDABDE”，和模式串P“ABCDABD”，现在要拿模式串P去跟文本串S匹配，整个过程如下所示：1.S[0]为B，P[0]为A，不匹配，执行第②条指令：“如果失配（即S[i]! = P[j]），令i = i - (j - 1)，j = 0”，S[1]跟P[0]匹配，相当于模式串要往右移动一位（i=1，j=0）2. S[1]跟P[0]还是不匹配，继续执行第②条指令：“如果失配（即S[i]! = P[j]），令i = i - (j - 1)，j = 0”，S[2]跟P[0]匹配（i=2，j=0），从而模式串不断的向右移动一位（不断的执行“令i = i - (j - 1)，j = 0”，i 从2变到4，j一直为0）3. 直到S[4]跟P[0]匹配成功（i=4，j=0），此时按照上面的暴力匹配算法的思路，转而执行第①条指令：“如果当前字符匹配成功（即S[i] == P[j]），则i++，j++”，可得S[i]为S[5]，P[j]为P[1]，即接下来S[5]跟P[1]匹配（i=5，j=1）4. S[5]跟P[1]匹配成功，继续执行第①条指令：“如果当前字符匹配成功（即S[i] == P[j]），则i++，j++”，得到S[6]跟P[2]匹配（i=6，j=2），如此进行下去5. 直到S[10]为空格字符，P[6]为字符D（i=10，j=6），因为不匹配，重新执行第②条指令：“如果失配（即S[i]! = P[j]），令i = i - (j - 1)，j = 0”，相当于S[5]跟P[0]匹配（i=5，j=0）6. 至此，我们可以看到，如果按照暴力匹配算法的思路，尽管之前文本串和模式串已经分别匹配到了S[9]、P[5]，但因为S[10]跟P[6]不匹配，所以文本串回溯到S[5]，模式串回溯到P[0]，从而让S[5]跟P[0]匹配。
K M P 算 法 详 解
KMP算法详解(转)此前一天，一位MS的朋友邀我一起去与他讨论快速排序，红黑树，字典树，B树、后缀树，包括KMP算法，唯独在讲解KMP算法的时候，言语磕磕碰碰，我想，原因有二：1、博客内的东西不常回顾，忘了不少；2、便是我对KMP算法的理解还不够彻底，自不用说讲解自如，运用自如了。
所以，特再写本篇文章。
由于此前，个人已经写过关于KMP算法的两篇文章，所以，本文名为：KMP算法之总结篇。
本文分为如下六个部分：第一部分、再次回顾普通的BF算法与KMP算法各自的时间复杂度，并两相对照各自的匹配原理；第二部分、通过我此前第二篇文章的引用，用图从头到尾详细阐述KMP算法中的next数组求法，并运用求得的next数组写出KMP算法的源码；第三部分、KMP算法的两种实现，代码实现一是根据本人关于KMP算法的第二篇文章所写，代码实现二是根据本人的关于KMP算法的第一篇文章所写；第四部分、测试，分别对第三部分的两种实现中next数组的求法进行测试，挖掘其区别之所在；第五部分、KMP完整准确源码，给出KMP算法的准确的完整源码；第六步份、一眼看出字符串的next数组各值，通过几个例子，让读者能根据字符串本身一眼判断出其next数组各值。
力求让此文彻底让读者洞穿此KMP算法，所有原理，来龙去脉，让读者搞个通通透透（注意，本文中第二部分及第三部分的代码实现一的字符串下标i从0开始计算，其它部分如第三部分的代码实现二，第五部分，和第六部分的字符串下标i 皆是从1开始的）。
第一部分、KMP算法初解1、普通字符串匹配BF算法与KMP算法的时间复杂度比较KMP算法是一种线性时间复杂的字符串匹配算法，它是对BF算法（Brute-Force，最基本的字符串匹配算法的）改进。
对于给的原始串S 和模式串P，需要从字符串S中找到字符串P出现的位置的索引。
BF算法的时间复杂度O(strlen(S) * strlen(T))，空间复杂度O(1)。
KMP算法（改进后的字符串匹配算法）
KMP算法（改进后的字符串匹配算法）kmp算法完成的任务是：给定两个字符串O和f，长度分别为n和m，判断f是否在O中出现，如果出现则返回出现的位置。
常规⽅法是遍历a的每⼀个位置，然后从该位置开始和b进⾏匹配，但是这种⽅法的复杂度是O(nm)。
kmp算法通过⼀个O(m)的预处理，使匹配的复杂度降为O(n+m)。
这种算法不太容易理解，⽹上有很多解释，但读起来都很费劲。
直到读到Jake Boxer的⽂章，我才真正理解这种算法。
下⾯，我⽤⾃⼰的语⾔，试图写⼀篇⽐较好懂的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，因此按照下⾯的公式算出向后移动的位数： 移动位数 = 已匹配的字符数 - 对应的部分匹配值 因为 6 - 2 等于4，所以将搜索词向后移动4位。
《kmp算法报告》word版
摘要关键词匹配(Keyword Matching)有时也称为模式匹配(Pattern Matching)，是计算机科学中一个基本问题，也是一个经典的算法问题。
该算法目前被广泛用于信息处理、网络信息过滤、入侵检测系统和生物信息计算的基因序列比较等工作中。
本文首先分别介绍单模式匹配和多模式匹配的经典算法，单模式匹配算法主要分析了KMP算法和BM算法，多模式匹配算法详细分析了Wu-Manber多模式匹配算法，并对其进行了改进，最后通过实验对几种算法的复杂度进行了比较。
1.引言简单的说关键词匹配问题就是从给定的文本(Text)中，找出所有的需要匹配的模式(Pattern)。
一类匹配问题是预先知道文本，再根据动态给出的模式进行匹配，例如搜索引擎预先收集Web页信息，再跟据用户输入的关键词进行匹配查找，处理这类问题需要对已知的文本做一些处理来加速匹配过程，一般采用对文本加索引的方式；另一类匹配问题是预先知道模式，在不同的文本中进行匹配，例如用关键词过滤信息，根据特征码检查病毒等都属于这类问题。
根据待匹配的关键词的个数又可以分为单模式匹配和多模式匹配。
另外根据匹配的方式还可以分为基于字符比较匹配(character parison)和基于非字符比较匹配(主要将字符串看作bit串来处理和一些数值型的方法)两种。
本文要讨论的是预先知道模式的情况下基于字符比较的模式匹配问题，本文首先分别介绍单模式匹配和多模式匹配的经典算法，其中详细分析了Wu-Manber多模式匹配算法，并对其进行了改进，最后通过实验对几种算法的复杂度进行了比较。
2.单模式匹配算法单模式匹配就是在给定的文本(Text)中对给定的单个关键词样本(Pattern)进行搜索，并且返回所有的匹配。
最原始的匹配算法是平凡算法，即用关键从文本起始位置开始比较，每次匹配不论成功与否都将关键词在当前文本处右移一位。
平凡算法在正确性上是没有问题的，但是由于每次只将Pattern右移一位导致匹配时间很长。
并行KMP算法的研究
1 引言 字符串的模式匹配是对字符串的基本操作之
一袁广泛应用于生物信息学尧信息检索尧拼写检查尧 语言翻译尧数据压缩尧网络入侵检测等领域袁如何简 化其复杂性一直是算法研究中的经典问题.字符串 的模式匹配实质上就是寻找模式串 P 是否在主串 T 中袁且其出现的位置.现如今我们对字符串匹配的 效率的要求越来越高袁 应不断地改良模式匹配算 法袁减少其时间复杂度. 2 相关模式匹配算法分析渊n 为主串长袁m 为模式 串长冤 2.1 BF渊Brute Force冤算法
P: a b d 第二趟院T: a b c a b d b b d
P: b d 第三趟院T: a b c a b d b b d
P: a b d 可以看出袁get_next 算法是该匹配算法的核心袁 通过 next 数组可以让模式串在失配时快速地向右 移动袁 主串中 i 也不用回溯. 遍历模式串得到 next 数组袁所以时间复杂度是 O(m)袁模式串在主串中的 匹配过程由于模式串每次移动的长度 j-next[j]与 i 的移动距离大致相当袁所以匹配的时间复杂度是与 主串长成线性关系袁为 O(n)[1].综上袁该模式匹配算 法的复杂度为 O(m+n). 3 并行 KMP 算法 假设模式串出现在主串的尾部袁 按照 KMP 算 法需要从第一个开始一直匹配到最后一个开始袁需 要遍历整个主串. 现提出并行 KMP 算法同时在主 串的末尾开始匹配袁既然要从末尾开始匹配袁那么 就需要新的数组从 m 串的末尾开始记录前后缀的 长度袁有两种选择院1.存储一个新串袁使新串为原模 式串的逆序袁 再调用 get_next 函数得到 next2 数组 记录前后缀长度[2].2.定义新的 get_nextrev 函数袁直 接从模式串的尾部开始通过调用 get_nextrev 获得 新的 nextrev 数组记录前后缀长度. 这两种方法明 显后者优于前者袁因为方法 1 还得额外存储一个字 符串浪费空间[3].get_next 函数伪代码如下院 Abstract get_next: { int j=-1,i=0,next[0]=-1;
浅论《数据结构》中KMP模式匹配算法讲解
DOI：10.16661/ki.1672-3791.2019.19.196浅论《数据结构》中KMP模式匹配算法讲解杨凌雪 田宏兵(六盘水师范学院数学与信息工程学院 贵州六盘水 553004)摘 要：模式匹配是《数据结构》中关于字符串的一个基本运算，一般有两种方法，分别为“朴素算法”与“KMP算法”。
KMP算法是一种高效的字符匹配算法，它的关键在于当字符匹配失败以后，利用next数组中的信息使指针不需要回退，这样就减少了匹配的次数，提高效率。
KMP算法不容易理解，该文通过举例等方法分析KMP算法的匹配原理及过程。
关键词：模式匹配 next数组 KMP算法讲解中图分类号：TP311.12-4 文献标识码：A 文章编号：1672-3791(2019)07(a)-0196-03Abstract: Pattern matching is a basic operation on strings in Data Structure. There are generally two methods, namely "simple algorithm" and "KMP algorithm". The KMP algorithm is an efficient character matching algorithm. The key is that the information in the next array is used to make the pointer don't need to be rolled back when the character matching fails, thus reducing the number of matching and improving efficiency. The KMP algorithm is not easy to understand. This paper analyzes the matching principle and process of KMP algorithm by examples.Key Words: Pattern matching; Next array; KMP algorithm explanation字符串的模式匹配，即找寻字符串p第一次出现在字符串t中的起始位置。
KMP算法的FPGA实现毕业论文
(此文档为word格式，下载后您可任意编辑修改！)本科毕业设计（2011届）题目KMP算法的FPGA实现学院电子信息学院专业集成电路设计与集成系统班级学号学生姓名褚小伟指导教师李训根完成日期2011年3月诚信承诺我谨在此承诺：本人所写的毕业论文《KMP算法的FPGA实现》均系本人独立完成，没有抄袭行为，凡涉及其他作者的观点和材料，均作了注释，若有不实，后果由本人承担。
承诺人（签名）：年月日摘要随着网络技术的迅猛发展，所要检测的数据包越来越多，单纯的依靠软件来检测，越来越显得力不从心。
伴随着FPGA技术的发展，在硬件上实现模式匹配，来提高网络数据处理速度的需求越来越普遍。
把搜索算法固化到FPGA里，从而可以大大提高算法的速度，适应科技的迅速发展。
本文重点分析了几种典型的模式匹配算法。
包括：BF算法、KMP算法、BM算法、BMH算法、AC算法和AC-BM算法。
另外文章还介绍了FPGA的的相关基本知识以及硬件描述语言的选择。
综合考虑现有的比较成熟的模式匹配算法，并且追踪国外基于FPGA技术来实现模式匹配的研究成果，认为在硬件实现方面，KMP算法效率较高，结构简单，可行性强，而且易于对主串进行多模式的匹配，所以选其作为模式匹配硬件模块的核心算法，通过硬线逻辑来进一步提高串模式匹配的效率。
本文KMP算法程序设计部分主要分为三个部分：模式串输入、next函数的计算、字符串的匹配。
具体情况会在第四章中介绍。
关键词：模式匹配算法；KMP算法；FPGAABSTRACTWith the rapid development of network technology, software to detect becomes more and more inadequate.As the development of FPGA technology, it’s becomes increasingly popular to realize the pattern matching on greatly improve the speed of the algorithm, is adapt to the quick development of technology.This paper focuses on several typical patterns matching algorithm involving: BF algorithm, KMP algorithm, BM algorithm, BMH algorithm, AC algorithm and the AC-BM algorithm.Besides, this paper will also introduce the basic knowledge related to FPGA as well as the selection of the description language of matching algorithms which are relatively through and the reseaching findings from abroad of using FPGA to achieve pattern mactching, KMP , strong feasibility and easy multi-pattern macthing to primary string in realizing why choose it to be the core arithmetic of matching pattern and effiency of pattern maching in string by via string entered, next function calculation, string matching. The circumstances described in the fourth chapter.Key words：Pattern matching algorithm；KMP algorithm；FPGA目录第1章引言 (1)1.1研究背景 (1)1.2模式匹配算法的发展与研究现状 (1)第2章模式匹配算法 (3)2.1模式匹配定义 (3)2.2单模式匹配 (3)2.2.1BF算法 (3)2.2.2KMP算法 (4)2.2.3BM算法 (6)2.2.4BMH算法 (7)2.3多模式匹配 (7)2.3.1AC算法 (7)2.3.2AC-BM算法 (8)2.4影响模式匹配算法的因素 (9)第3章FPGA基本的知识 (11)3.1FPGA简介 (11)3.2FPGA与CPLD的关系以及工作原理 (11)3.3硬件语言选择 (12)第4章KMP算法VerilogHDL实现 (14)4.1模式串输入 (14)4.2next函数的计算 (15)4.3字符串匹配 (19)4.4代码通用性的验证 (22)第5章结束语 (27)致谢 (28)附录 (31)第1章引言1.1研究背景[1]在网络处理中，模式匹配是指将分组各域进行比特位的匹配处理。
模式匹配的kmp算法
模式匹配的kmp算法Kmp算法是由Knuth、Morris、Pratt与1969年夏天提出的快速串匹配算法，它是由对BF算法的很大改进而成的，这主要体现在每当某趟匹配失败是，指针不必回溯，而是利用已经得到的“部分匹配”结果，将模式向右“滑动“若干个位置后继续比较。
由于KMP算法避免了BF算法中频繁的回溯，普遍提高了模式匹配的工作效率，因此它又被称为“不回溯的字符串搜索算法”。
假设有目标串T(t0,t1,t2,t3……,t m-1)和模式串P(p０,p1,p2,p3,…p n-1),使用BF算法进行模式匹配，当进行第一轮比较时，若t k≠p k，则算法结束本轮比较，如下所示：T t0,t1,t2,…t k,t k+1,…t n-2,t n-1,…t m-2,t m-1P p0,p1,p2,…p k,p k+1…,p n-2,p n-1 （第一轮比较结束）由于在字符串Ｔ与Ｐ中第一个不相等的字符位于ｋ处，所以两字符串前ｋ个字符是相等的。
此时，可用字符串P(p0,p1,p2,p3,…p k-1)字符串T(t0,t1,t2,t3……,t k-1)，于是原目标串可转化为T(p0,p1,p2,p3,…p k-1，p k……,t m-1)。
在进行第二轮比较前，算法同样把字符串P整体向后移动一个字符，此时字符串T与P之间的关系如下：T p0,p1,p2,…p k-1,p k, …t n-2,t n-1,…t m-2,t m-1P p0,p1,p2,…p k,p k+1…,p n-2,p n-1(第二轮比较)在第二轮比较中算法首先要比较的字符是P中首字符p0与T中第二个字符p1，若p0与p1相等，则算法顺序比较P中第二个字符p1与T中第三个字符p2；若不等，则算法仍然把模式串P整体向后移动一个字符，此时字符串T与P之间的关系如下T p0,p1,p2,…p k-1,p k, …t n-2,t n-1,…t m-2,t m-1P p0,…p k-3,p k-2,…,p n-1（第三次比较）算法依照同样的次序，首先对P中字符p0与T中字符p2进行比较，若相等，则顺序比较后续的字母；若不等，则把字符串P整体向后移动一个字符。
关于kmp算法改进的探讨
1020 引言KMP算法是一种字符串比较算法,相对于BF算法,它有比较大的改进,也是一款经典的算法,且它在计算机应用系统中如文本编辑、情报检索、自然语言翻译有着广泛的应用[1],是每一个想学习字符串匹配的人必须要了解的一个算法,但相信很多人初识KMP算法的时候都是知其然而不知其所以然,对于其next[j]数组更是一头雾水。
1 kmp算法的研究与分析1.1 kmp算法的概述对于朴素的模式匹配算法即BF算法,它的基本思想是:有主串s和模式串(子串)t,要求找出模式串t在s串中的首次出现的位置。
若当前字符匹配成功(即s[i]==t[j],i为主串的下标,j为模式串的下标),则i++,j++,继续匹配下一个字符;如果失配(即s[i]!=t[j]),令i回溯到i-j+1的位置,j回到模式串起始字符位置,这样的算法比较次数多,相当耗时。
为了提高效率KMP算法对BF算法做了改进,其核心思想就是减少比较的次数即让主串s没必要的回溯不发生,它的最大改进在于在匹配过程中失配的情况下,将模式串t有效地多往后面跳几个字符,加快匹配速度,那究竟能有效的往后面跳几个字符来减少次数呢,kmp算法认为,匹配过程与模式串的特征关系密切,如果对于模式串中存在一个整数k(k<j),使得模式串t中第K个字符之前的k个字符(t[0],t[1]...t[k-1])依次与t[j]的前面k-1个字符(t[j-k]t[j-k+1]...t[j-1])相同,并与主串s中第i个字符之前的k个字符相等,那么匹配仅需要从模式串t中的第k个字符与主串的第i个字符起继续比较[2]。
1.2 kmp算法的形成过程分析在以下例子中s串的下标i与t串的下标j都是从1开始。
第一种情况是t串在失配字符前没有重复字符的情况时:第一次匹配是s串iambabynigthowl与t串iambe在下标为5的元素失配时(即s[5]!=t[5]),直观t串失配字符前的几个元素发现并不相等,即t[1]≠t[2]≠t[3]≠t[4],而在失配前s串与t串的前4个字符一一对应,所以可以判断出t[1]字符与s串的前四个字符都不相同,所以第二次比较直接将t[1]字符与s[5]字符开始比较即可,子串向右滑动了4个字符,相比于BF算法,s串的下标i没有回到s[2]的位置重新与t[1]字符开始比较,比较次数减少了三次。
KMP模式匹配算法探讨
摘要介绍了ＫＭＰ算法并与朴素查找算法进行了比较，提出了前缀函数的概念，并利用改进的前缀函数改进KMP算法，最后结合ＫＭＰ的改进算法给出了多次匹配的算法。
关键词串匹配，前缀函数，KMP算法在计算机科学领域，串的模式匹配（以下简称为串匹配）算法一直都是研究焦点之一。
在拼写检查、语言翻译、数据压缩、搜索引擎、网络入侵检测、计算机病毒特征码匹配以及DNA序列匹配等应用中，都需要进行串匹配。
串匹配就是在主串中查找模式串的一个或所有出现。
在本文中主串表示为S=s1s2s3…sn，模式串表示为T=t1t2…tm。
串匹配从方式上可分为精确匹配、模糊匹配、并行匹配等，著名的匹配算法有BF算法、KMP算法、BM算法及一些改进算法。
本文主要在精确匹配方面对KMP算法进行了讨论并对它做一些改进以及利用改进的KMP来实现多次模式匹配。
1KMP算法最简单的朴素串匹配算法(BF算法)是从主串的第一个字符和模式串的第一个字符进行比较，若相等则继续逐个比较后续字符，否则从主串的第二个字符起再重新和模式串的第一个字符进行比较。
依次类推，直至模式串和主串中的一个子串相等，此时称为匹配成功，否则称为匹配失败。
朴素模式匹配算法匹配失败重新比较时只能向前移一个字符，若主串中存在和模式串只有部分匹配的多个子串，匹配指针将多次回溯，而回溯次数越多算法的效率越低，它的时间复杂度一般情况下为O((n-m+1)m)（注：n和m分别为主串和模式串的长度），最坏的情况下为O(m*n)，最好的情况下为O(m+n)。
KMP模式匹配算法正是针对上述算法的不足做了实质性的改进。
其基本思想是：当一趟匹配过程中出现失配时，不需回溯主串，而是充分利用已经得到的部分匹配所隐含的若干个字符，过滤掉那些多余的比较，将模式串向右“滑动”尽可能远的一段距离后，继续进行比较，从而提高模式匹配的效率，该算法的时间复杂度为O(m+n)。
那么如何确定哪些是多余的比较？在KMP算法中通过引入前缀函数f(x)来确定每次匹配不需要比较的字符，保证了匹配始终向前进行，无须回溯。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
文献综述
一般使用的计算机的硬件结构主要反映数值计算的需要，而计算机上的非数值处理的对象基本上是字符串数据，因此在处理字符串数据时比处理整数和浮点数要复杂的很多。
随着程序语言将程序的发展，字符串的处理也有了越来越多的研究。
子串的定位炒作通常称为串的模式匹配，是各种处理系统中最重要的操作之一。
串匹配问题是指从给定的字符序列中找出一个或多个具有某种属性的模式序列，而字符串匹配指的便是从给定的字符序列中找出一个或若干个给定的字符串。
字符串匹配算法是一个基础算法，它的解决以及在这个过程中产生的方法对计算机的其他问题都产生了巨大的影响。
在我们日常使用计算机的过程中，使用字符串匹配技术的例子十分普遍，例如：入侵检测、病毒检测、信息检索、信息过滤、计算生物学等等都包含了字符串匹配技术。
在字符串匹配技术被广泛应用的同时，众多的科技人员也对其进行了深入的研究，字符串匹配问题现在已经发展成为一门相对独立的科学——字符串学（Stingology）[1][2][3]。
字符串匹配技术最先被应用于图书文献目录摘要的查询系统和构建数据的全文检索系统。
而后，随着网络安全技术和生物技术的日益发展，在网络安全和生物计算等领域中字符串匹配技术又获得了新的发展空间。
随着网络速度和流量的日益增加，基于网络的入侵检测[4][5]系统面临着严峻的挑战，它的处理、分析速度越来越难以跟上网络流量增加速度，从而极易导致数据包的丢失。
解决数据包丢失等问题，提高处理速度是关键。
另外对于基于误用的入侵检测系统而言，检测过程中最费时的部分便是入侵特征匹配。
目前，信息资源的高速膨胀已经成为一个全球普遍关注的现象。
加利福尼亚大学伯克利分校研究人员发现，仅从1999年至2002年全球新产生的信息量就翻了一番。
伴随着信息膨胀，信息的良莠不齐现象也是一个严重困扰人们的问题。
大量反动、黄色信息以及国家机密在网络上蔓延和传播，给国建安全和社会稳定造成了严重的威胁，如何对这些不良信息进行网络监控是我们面临的一个重要问题。
在信息过滤时，特别是在主干网络上进行过滤与检索，对字符串匹配的实时性要求极高，字符串匹配性能的优劣直接影响了过滤与检索系统的性能。
随着生命科学的发展，人们对生命物质的微观结构也有了越来越清晰的认识。
目前，人类基因组序列的绘制工作已完成，Prosite等大型蛋白质重要样本数
据库已经建立[6]。
由于基因和蛋白质都可以用建立在一定字符集上的符号序列来表示，因此字符串匹配技术变有了新的发展空间。
在计算生物学中，海量的基因组序列数据和蛋白质序列数据中进行比对、分析、组合的基本是字符串匹配技术。
综上所述，随后则计算机技术和网络技术的发展，模式匹配算法的重要性越发突出，研究设计高效率的匹配算法这是计算机技术发展的迫切需求，为了在最快的时间内研究设计出高效的匹配算法，我们必须学习和借鉴一些经典的算法，其中KMP算法最具有代表性，在最坏的情况下它能保证在O(n+m)的时间数量级上完成串的模式匹配操作。
KMP算法的最大特点是指示主串的指针不须回溯，整个匹配过程中，对主串仅需从头到尾扫描一遍，这对处理从外设输入的庞大文件很有效，可以边度入边匹配，而无需回头重读。
它的这些优点使其成为经典算法之一，而其算法的衍生算法数量也极其庞大，所以我们很有必要对其学习研究。
参考文献
[1]严蔚敏，吴伟民.数据结构(C语言版) [M].北京:清华大学出版社，2008.9
[2]刘燕兵.串匹配算法优化的研究.中国科学院硕士学位论文-中国科学院计算技术研究所,2006.6
[3]潘金贵，顾铁成.算法导论.[M].机械工业出版社，2010.9
[4]吴哲辉，曹立明，蒋昌俊.算法分析与设计[M].北京:煤炭工业出版社，2006.6。