KMP匹配的模式算法——保姆级解读（图文版）
目录
一，写在前面
二，朴素的模式匹配算法
三，KPM的模式匹配算法
1，算法原理
2，NEXT数组推导
3，算法实现
4，算法改进
四，全部代码
五，结后语
一，写在前面
了解一种优化和高效算法，是基于一定普通算法改良和提升的，讲KMP算法前，我们应该首先了解朴素的模式算法。
二，朴素的模式匹配算法
找一个单词在一篇文章（相当于一个大字符串）中的定位问题。这种子串的定位操作通常称做串的模式匹配,应该算是串中最重要的操作之一。
假设我们要从下面的主串 S="goodgoogle”中，找到T=“google"这个子串的位置。我们通常需要下面的步骤。
1.主串S第一位开始,S与T前三个字母都匹配成功，但S第四个字母是d而T的是g。第一位匹配失败。如图所示，其中竖直连线表示相等，闪电状弯折连线表示不等。
2，主串S第二位开始，主串S首字母是o，要匹配的T首字母是g，匹配失败,
3，主串S第三位开始，主串S首字母是o，要匹配的T首字母是g，匹配失败，
4，主串S第四位开始，主串S首字母是d，要匹配的T首字母是g，匹配失败，
5，主串S第五位开始,S与T,6个字母全匹配,匹配成功,
简单的说，就是对主串的每一个字符作为子串开头，与要匹配的字符串进行匹配。对主串做大循环，每个字符开头做T的长度的小循环，直到匹配成功或全部遍历完成为止。
前面我们已经用串的其他操作实现了模式匹配的算法 Index。现在考虑不用串的其他操作，而是只用基本的数组来实现同样的算法。注意我们假设主串S和要匹配的子串T的长度存在S[0]与T[0]中。实现代码如下:
/* 返回子串T在主串S中第pos个字符之后的位置。若不存在，则函数返回值为0。 */
/* T非空，1≤pos≤StrLength(S)。 */
int Index_KMP(String S, String T, int pos)
{
int i = pos; /* i用于主串S中当前位置下标值，若pos不为1，则从pos位置开始匹配 */
int j = 1; /* j用于子串T中当前位置下标值 */
int next[255]; /* 定义一next数组 */
get_next(T, next); /* 对串T作分析，得到next数组 */
while (i <= S[0] && j <= T[0]) /* 若i小于S的长度并且j小于T的长度时，循环继续 */
{
if (j==0 || S[i] == T[j]) /* 两字母相等则继续，与朴素算法增加了j=0判断 */
{
++i;
++j;
}
else /* 指针后退重新开始匹配 */
j = next[j];/* j退回合适的位置，i值不变 */
}
if (j > T[0])
return i-T[0];
else
return 0;
}分析一下，最好的情况是什么?那就是一开始就区配成功，比如“googlegood”中去找“googe”，时间复杂度为0[1)。稍差一些，如果像刚才例子中第二、三、四位一样，每次都是首字母就不匹配，那么对T串的循环就不必进行了，比如“"abcdefgoogle”中去找“google”。那么时间复杂度为0(n+m)，其中n为主串长度，m为要匹配的子串长度。根据等概率原则，平均是(n+m)/2次查找，时间复杂度为o(n+m)。
那么最坏的情况又是什么?就是每次不成功的匹配都发生在串T的最后一个字符。举一个很极端的例子。主串为S=“0o000000000000000000000000000000000000000000000001”，而要匹配的子串为 T=“0000000001”,前者是有49个“0”和1个“1”的主串，后者是9个“0”和1个“1”的子串。在匹配时，每次都得将T中字符循环到最后一位才发现:哦，原来它们是不匹配的。这样等于T串需要在S串的前40个位置都需要判断10次，并得出不匹配的结论，如图所示。
直到最后第41个位置，因为全部匹配相等，所以不需要再继续进行下去,如图所示。如果最终没有可匹配的子串，比如是T=“0000000002",到了第41位置判断不匹配后同样不需要继续比对下去。因此最坏情况的时间复杂度为O((n-m＋1)*m)。
在实际运用中，对于计算机来说，处理的都是二进位的0和1的串，一个字符的 ASCII 码也可以看成是8位的二进位01串，当然,汉字等所有的字符也都可以看成是多个0和1串。再比如像计算机图形也可以理解为是由许许多多个0和1的串组成。所以在计算机的运算当中，模式匹配操作可说是随处可见,而刚才的这个算法,就显得太低效了。
/* 朴素的模式匹配法 */
int Index(String S, String T, int pos)
{
int i = pos; /* i用于主串S中当前位置下标值，若pos不为1，则从pos位置开始匹配 */
int j = 1; /* j用于子串T中当前位置下标值 */
while (i <= S[0] && j <= T[0]) /* 若i小于S的长度并且j小于T的长度时，循环继续 */
{
if (S[i] == T[j]) /* 两字母相等则继续 */
{
++i;
++j;
}
else /* 指针后退重新开始匹配 */
{
i = i-j+2; /* i退回到上次匹配首位的下一位 */
j = 1; /* j退回到子串T的首位 */
}
}
if (j > T[0])
return i-T[0];
else
return 0;
}三，KPM的模式匹配算法
你们可以忍受朴素模式匹配算法的低效吗?也许不可以、也许无所谓。但在很多年前我们的科学家们，觉得像这种有多个0和1重复字符的字符串，却需要挨个遍历的算法是非常糟糕的事情。于是有三位前辈，D.E.Knuth、J.H.Morris和 VR.Pratt(其中Knuth 和 Pratt 共同研究，Morris 独立研究）发表一个模式匹配算法，可以大大避免重复遍历的情况，我们把它称之为克努特—莫里斯一普拉特算法，简称KMP算法。
1，算法原理
如果主串 S=“abcdefgab”，其实还可以更长一些，我们就省略掉只保留前9位，我们要匹配的 T=“abcdex”，那么如果用前面的朴素算法的话，前5个字母，两个串完全相等，直到第6个字母，“f”与“x”不等，如图的①所示。
接下来，按照朴素模式匹配算法，应该是如图的流程②③④⑤⑥。即主串S中当i=2、3、4、5、6时，首字符与子串T的首字符均不等。
似乎这也是理所当然，原来的算法就是这样设计的。.可仔细观察发现。对于要匹配的子串T来说，"abcdex”首字母“a”与后面的串“bcdex”中任意一个字符都不相等。也就是说，既然“a”不与自己后面的子串中任何一字符相等，那么对于图的①来说，前五位字符分别相等，意味着子串T的首字符“a”不可能与S串的第2位到第5位的字符相等。在图中，②③④⑤的判断都是多余。
注意这里是理解KMP算法的关键。如果我们知道T串中首字符“a”与T中后面的字符均不相等（注意这是前提，如何判断后面再讲)。而T串的第二位的“b”与S串中第二位的“b”在图的①中已经判断是相等的，那么也就意味着，T串中首字符“a”与S串中的第二位“b”是不需要判断也知道它们是不可能相等了，这样图的②这一步判断是可以省略的，如图下所示。
同样道理，在我们知道T串中首字符“a”与T中后面的字符均不相等的前提下，T串的“a”与S串后面的“c”、"d”、“e”也都可以在①之后就可以确定是不相等的，所以这个算法当中②③④⑤没有必要，只保留①⑥即可，如图所示。
之所以保留⑥中的判断是因为在①中 T[6]≠S[6]，尽管我们已经知道T[1]≠T[6]，但也不能断定T[1]一定不等于S[6]，因此需要保留⑥这一步。
有人就会问，如果T串后面也含有首字符“a”的字符怎么办呢?
我们来看下面一个例子，假设S=“abcabcabc”,T=“abcabx”。对于开始的判断，前5个字符完全相等，第6个字符不等，如图的①。此时,根据刚才的经验，T的首字符“a”与T的第二位字符“b"、第三位字符“℃”均不等，所以不需要做判断，图的朴素算法步骤②③都是多余。
因为T的首位“a”与T第四位的“a”相等，第二位的“b”与第五位的“b”相等。而在①时，第四位的“a”与第五位的“b”已经与主串S中的相应位置比较过了，是相等的，因此可以断定，T的首字符“a”、第二位的字符“b”与S的第四位字。
符和第五位字符也不需要比较了，肯定也是相等的——之前比较过了，还判断什么,所以④⑤这两个比较得出字符相等的步骤也可以省略。
也就是说，对于在子串中有与首字符相等的字符，也是可以省略一部分不必要的判断步骤。如图所示，省略掉右图的T串前两位“a”与“b”同S串中的4、5位置字符匹配操作。
对比这两个例子，我们会发现在①时，我们的主值，也就是主串当前位置的下标是6，23④5,i值是2、3、4、5,到了⑥,i值才又回到了6。即我们在朴素的模式匹配算法中，主串的i 值是不断地回溯来完成的。而我们的分析发现，这种回溯其实是可以不需要的——正所谓好马不吃回头草，我们的 KMP模式匹配算法就是为了让这没必要的回溯不发生。
既然主值不回溯，也就是不可以变小，那么要考虑的变化就是j值了。通过观察也可发现，我们屡屡提到了T串的首字符与自身后面字符的比较，发现如果有相等字符,j值的变化就会不相同。也就是说，这个j值的变化与主串其实没什么关系，关键就取决于T串的结构中是否有重复的问题。
比如图中，由于T="abcdex"，当中没有任何重复的字符,所以j就由6变成了1。而图中，由于T="abcabx"，前缀的“ab”与最后“x”之前串的后缀“ab”是相等的。因此j就由6变成了3。因此，我们可以得出规律,j值的多少取决于当前字符之前的串的前后缀的相似度。
2，NEXT数组推导
具体如何推导出一个串的next数组值呢,我们来看一些例子。
1.T="abcdex”(如表所示)
1)当=1时,next[1]=0;
2)当j=2时,j由1到j-1就只有字符“a”，属于其他情况next[2]=1;
3)当j=3时,j由1到j-1串是“ab”,显然“a”与“b”不相等，属其他情况，next[3]=1;
4)以后同理,所以最终此T串的nexti]为011111。
2. T="abcabx”(如表所示)
1)当j=1时，next[1]=0;
2)当j=2时,同上例说明，next[2]=1;3)当j=3时,同上，next[3]=1;
4)当j=4时,同上，next[4]=1;
5)当j=5时，此时j由1到j-1的串是“abca”，前缀字符“a”与后缀字符
“a”相等(前缀用下划线表示，后缀用斜体表示)，因此可推算出k值为2(由‘pr…pk-1'-'P)j-ki1…p-1'，得到p1=p4)因此next[5]=2;6)当j=6时,j由1到j-1的串是“abcab”，由于前缀字符“ab”与后缀“ab”
相等,所以next[6]=3。可以根据经验得到如果前后缀一个字符相等，k值是2，两个字符k值是3,
3.T="“ababaaaba"(如表所示)
1)当=1时，next[1]=0;
2)当j=2时，同上next[2]=1;
3）当j=3时,同上next[3]=1;
4)当j=4时,j由1到j-1的串是“aba”，前缀字符“a”与后缀字符“a”相
等，next[4]=2;5)当j=5时,j由1到j-1的串是“abab”，由于前缀字符“ab”与后缀“ab”
相等,所以next[5]=3;6)当j=6时,j由1到j-1的串是“ababa”，由于前缀字符“aba”与后缀
"aba”相等,所以next[6]=4;7)当j=7时，j由1到j-1的串是“ababaa”,由于前缀字符“ab”与后缀
“aa”并不相等，只有“a”相等，所以next[7]=2;8)当j=8时,j由1到j-1的串是“ababaaa”,只有“a”相等，所以
next[8]=2;9)当j=9时,j由1到j-1的串是“ababaaab”，由于前缀字符“ab”与后缀
“ab”相等,所以next[9]=3。
4, T="aaaaaaaab”(如表所示)
1)当j=1时，next[1]=0;
2)当j=2时,同上next[2]=1;
3)当j=3时,j由1到j-1的串是“aa”,前缀字符“a”与后缀字符“a”相
等，next[3]=2;4)当j=4时,j由1到j-1的串是“aaa”，由于前缀字符“aa”与后缀“aa”相
等，所以next[4]=3;5) ..…..
6)当j=9时,j由1到j-1的串是“aaaaaaaa”，由于前缀字符“aaaaaaa”与后缀“aaaaaaa”相等,所以next[9]=8。
3，算法实现
/* 通过计算返回子串T的next数组。 */
void get_next(String T, int *next)
{
int i,k;
i=1;
k=0;
next[1]=0;
while (i T[0])
return i-T[0];
else
4，算法改进
对于get_next函数来说，若T的长度为m，因只涉及到简单的单循环，其时间复杂度为0(m),而由于主值的不回溯，使得 index_KMP 算法效率得到了提高，while循环的时间复杂度为O(n)。因此，整个算法的时间复杂度为O(n+m)。相较于朴素模式匹配算法的O((n-m+1)*m)来说,是要好一些。
这里也需要强调，KMP算法仅当模式与主串之间存在许多“部分匹配”的情况下才体现出它的优势,否则两者差异并不明显。
后来有人发现，KMP还是有缺陷的。比如，如果我们的主串 S="aaaabcde”，子串T="aaaaax”"，其next 数组值分别为012345，在开始时，当 i=5、j=5时，我们发现b”与“a”不相等，如图的①，因此j=next[5]=4，如图中的②，此时“b”与第4位置的“a”依然不等，j=next[4]=3，如图中的③，后依次是④⑥，直到j=next[1]=0时,根据算法，此时i++、j++，得到 i=6、j=1，如图中的⑥。
我们发现，当中的②③④⑤步骤，其实是多余的判断。由于T串的第二、三、四、五位置的字符都与首位的“a”相等，那么可以用首位 next[1]的值去取代与它相等的字符后续next[i]的值,这是个很好的办法。因此我们对求next函数进行了改良。
假设取代的数组为nextval，增加了加粗部分，代码如下:
/* 求模式串T的next函数修正值并存入数组nextval */
void get_nextval(String T, int *nextval)
{
int i,k;
i=1;
k=0;
nextval[1]=0;
while (i四，全部代码
#include "string.h"
#include "stdio.h"
#include "stdlib.h"
#include "math.h"
#include "time.h"
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 100 /* 存储空间初始分配量 */
typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int ElemType; /* ElemType类型根据实际情况而定，这里假设为int */
typedef char String[MAXSIZE+1]; /* 0号单元存放串的长度 */
/* 生成一个其值等于chars的串T */
Status StrAssign(String T,char *chars)
{
int i;
if(strlen(chars)>MAXSIZE)
return ERROR;
else
{
T[0]=strlen(chars);
for(i=1;i<=T[0];i++)
T[i]=*(chars+i-1);
return OK;
}
}
Status ClearString(String S)
{
S[0]=0;/* 令串长为零 */
return OK;
}
/* 输出字符串T。 */
void StrPrint(String T)
{
int i;
for(i=1;i<=T[0];i++)
printf("%c",T[i]);
printf("\n");
}
/* 输出Next数组值。 */
void NextPrint(int next[],int length)
{
int i;
for(i=1;i<=length;i++)
printf("%d",next[i]);
printf("\n");
}
/* 返回串的元素个数 */
int StrLength(String S)
{
return S[0];
}
/* 朴素的模式匹配法 */
int Index(String S, String T, int pos)
{
int i = pos; /* i用于主串S中当前位置下标值，若pos不为1，则从pos位置开始匹配 */
int j = 1; /* j用于子串T中当前位置下标值 */
while (i <= S[0] && j <= T[0]) /* 若i小于S的长度并且j小于T的长度时，循环继续 */
{
if (S[i] == T[j]) /* 两字母相等则继续 */
{
++i;
++j;
}
else /* 指针后退重新开始匹配 */
{
i = i-j+2; /* i退回到上次匹配首位的下一位 */
j = 1; /* j退回到子串T的首位 */
}
}
if (j > T[0])
return i-T[0];
else
return 0;
}
/* 通过计算返回子串T的next数组。 */
void get_next(String T, int *next)
{
int i,k;
i=1;
k=0;
next[1]=0;
while (i T[0])
return i-T[0];
else
return 0;
}
/* 求模式串T的next函数修正值并存入数组nextval */
void get_nextval(String T, int *nextval)
{
int i,k;
i=1;
k=0;
nextval[1]=0;
while (i T[0])
return i-T[0];
else
return 0;
}
int main()
{
int i,*p;
String s1,s2;
StrAssign(s1,"abcdex");
printf("子串为: ");
StrPrint(s1);
i=StrLength(s1);
p=(int*)malloc((i+1)*sizeof(int));
get_next(s1,p);
printf("Next为: ");
NextPrint(p,StrLength(s1));
printf("\n");
StrAssign(s1,"abcabx");
printf("子串为: ");
StrPrint(s1);
i=StrLength(s1);
p=(int*)malloc((i+1)*sizeof(int));
get_next(s1,p);
printf("Next为: ");
NextPrint(p,StrLength(s1));
printf("\n");
StrAssign(s1,"ababaaaba");
printf("子串为: ");
StrPrint(s1);
i=StrLength(s1);
p=(int*)malloc((i+1)*sizeof(int));
get_next(s1,p);
printf("Next为: ");
NextPrint(p,StrLength(s1));
printf("\n");
StrAssign(s1,"aaaaaaaab");
printf("子串为: ");
StrPrint(s1);
i=StrLength(s1);
p=(int*)malloc((i+1)*sizeof(int));
get_next(s1,p);
printf("Next为: ");
NextPrint(p,StrLength(s1));
printf("\n");
StrAssign(s1,"ababaaaba");
printf(" 子串为: ");
StrPrint(s1);
i=StrLength(s1);
p=(int*)malloc((i+1)*sizeof(int));
get_next(s1,p);
printf(" Next为: ");
NextPrint(p,StrLength(s1));
get_nextval(s1,p);
printf("NextVal为: ");
NextPrint(p,StrLength(s1));
printf("\n");
StrAssign(s1,"aaaaaaaab");
printf(" 子串为: ");
StrPrint(s1);
i=StrLength(s1);
p=(int*)malloc((i+1)*sizeof(int));
get_next(s1,p);
printf(" Next为: ");
NextPrint(p,StrLength(s1));
get_nextval(s1,p);
printf("NextVal为: ");
NextPrint(p,StrLength(s1));
printf("\n");
StrAssign(s1,"00000000000000000000000000000000000000000000000001");
printf("主串为: ");
StrPrint(s1);
StrAssign(s2,"0000000001");
printf("子串为: ");
StrPrint(s2);
printf("\n");
printf("主串和子串在第%d个字符处首次匹配（朴素模式匹配算法）\n",Index(s1,s2,1));
printf("主串和子串在第%d个字符处首次匹配（KMP算法） \n",Index_KMP(s1,s2,1));
printf("主串和子串在第%d个字符处首次匹配（KMP改良算法） \n",Index_KMP1(s1,s2,1));
return 0;
}
五，结后语
如果你看到了这里，求转发求赞求评论，你的三连是我进步的最大动力!!!