简介
KMP算法是拿来处理字符串匹配的。换句话说，给你两个字符串，你需要回答，B串是否是A串的子串（A串是否包含B串）。比如，字符串A=”I’m matrix67”，字符串B=”matrix”，我们就说B是A的子串。
操作原理
假如，A=”abababaababacb”，B=”ababacb”。两个指针i和j表示，A[i-j+ 1..i]与B[1..j]完全相等。就是说，i不断增加，j随着i变化，现在检验A[i+1]和B[j+1]。当A[i+1]=B[j+1]，i和j各加一；当j=m，则B是A的子串，还能知道匹配位置。当A[i+1]<>B[j+1]，就减小j使A[i-j+1..i]=B[1..j]。
当 i=j=5：
i = 1 2 3 4 5 6 7 8 9 ……
A = a b a b a b a a b a b …
B = a b a b a c b
A[6]<>B[6]。j不能等于5了，要改成比它小的值j’。j’当然越大越好。B [1..5]=”ababa”，头3个字母和末3个字母都是”aba”。j’为3时，A[6]=B[4]。于是，i变成6，j变成 4：
i = 1 2 3 4 5 6 7 8 9 ……
A = a b a b a b a a b a b …
B = a b a b a c b
j = 1 2 3 4 5 6 7
从这个例子可以看到，j’取值与i无关，只与B串有关。可以预处理出数组P[j]，表示B数组第j+1个字母不能匹配时，j’最大值。P[j]是所有满足B[1..P[j]]=B[j-P[j]+1..j]的最大值。
然后，A[7]=B[5]，i和j各加1。这时又出现了A[i+1]<>B[j+1]的情况：:
i = 1 2 3 4 5 6 7 8 9 ……
A = a b a b a b a a b a b …
B = a b a b a c b
j = 1 2 3 4 5 6 7
由于P[5]=3，因此j’=3：
i = 1 2 3 4 5 6 7 8 9 ……
A = a b a b a b a a b a b …
B = a b a b a c b
j = 1 2 3 4 5 6 7
但j’=3仍不满足A[i+1]=B[j+1]，则再次减小j’，将j’再次更新为P[3]：
i = 1 2 3 4 5 6 7 8 9 ……
A = a b a b a b a a b a b …
B = a b a b a c b
j = 1 2 3 4 5 6 7
现在，i是7，j变成1。而A[8]仍不等于B[j+1]，所以j’必须减小到P[1]，即0：
i = 1 2 3 4 5 6 7 8 9 ……
A = a b a b a b a a b a b …
B = a b a b a c b
j = 0 1 2 3 4 5 6 7
终于，A[8]=B[1]，i变为8，j为1。事实上，有可能j=0仍不满足A[i+1]=B[j+1]（比如A[8]=”d”时）。因此，当j=0就增加i值忽略j直到出现A[i]=B[1]。
代码很短：
p[0]=-1;
for (i=1,j=0;i<=len1;)
{
if(j==-1) ++i,j=0;
if(s1[i]==s2[j+1]) ++i,++j;
else j=p[j];
if(j==len2) printf("%d\n",i-j),j=0;
}最后的j:=P[j]是为了让程序继续做下去，因为我们有可能找到多处匹配。
这个程序或许比想像中的要简单，因为对于i值的不断增加，代码用的是for循环。因此，这个代码可以这样形象地理解：扫描字符串A，并更新可以匹配到B的什么位置。
现在，我们还遗留了两个重要的问题：一，为什么这个程序是线性的；二，如何快速预处理P数组。
为什么这个程序是O(n)的？其实，主要的争议在于，while循环使得执行次数出现了不确定因素。我们将用到时间复杂度的摊还分析中的主要策略，简单地说就是通过观察某一个变量或函数值的变化来对零散的、杂乱的、不规则的执行次数进行累计。KMP的时间复杂度分析可谓摊还分析的典型。我们从上述程序的j 值入手。每一次执行while循环都会使j减小（但不能减成负的），而另外的改变j值的地方只有第五行。每次执行了这一行，j都只能加1；因此，整个过程中j最多加了n个1。于是，j最多只有n次减小的机会（j值减小的次数当然不能超过n，因为j永远是非负整数）。这告诉我们，while循环总共最多执行了n次。按照摊还分析的说法，平摊到每次for循环中后，一次for循环的复杂度为O(1)。整个过程显然是O(n)的。这样的分析对于后面P数组预处理的过程同样有效，同样可以得到预处理过程的复杂度为O(m)。
预处理不需要按照P的定义写成O(m^2)甚至O(m^3)的。我们可以通过P[1],P[2],…,P[j-1]的值来获得P[j]的值。对于刚才的B=”ababacb”，假如我们已经求出了P[1],P[2],P[3]和P[4]，看看我们应该怎么求出P[5]和P[6]。P[4]=2，那么P [5]显然等于P[4]+1，因为由P[4]可以知道，B[1,2]已经和B[3,4]相等了，现在又有B[3]=B[5]，所以P[5]可以由P[4] 后面加一个字符得到。P[6]也等于P[5]+1吗？显然不是，因为B[ P[5]+1 ]<>B[6]。那么，我们要考虑“退一步”了。我们考虑P[6]是否有可能由P[5]的情况所包含的子串得到，即是否P[6]=P[ P[5] ]+1。这里想不通的话可以仔细看一下：
1 2 3 4 5 6 7
B = a b a b a c b
P = 0 0 1 2 3 0 0
P[5]=3是因为B[1..3]和B[3..5]都是”aba”；而P[3]=1则告诉我们，B[1]和B[5]都是”a”。既然P[6]不能由P [5]得到，或许可以由P[3]得到（如果B[2]恰好和B[6]相等的话，P[6]就等于P[3]+1了）。显然，P[6]也不能通过P[3]得到，因为B[2]<>B[6]。事实上，这样一直推到P[1]也不行，最后，我们得到，P[6]=0。
怎么这个预处理过程跟前面的KMP主程序这么像呢？其实，KMP的预处理本身就是一个B串“自我匹配”的过程。它的代码和上面的代码神似：
int i,j;p[0]=-1;
for (i=0,j=2;j<=len2;)
{
if(i==-1) ++j,i=0;
if(s2[i+1]==s2[j])
{
p[j]=i+1;
++i,++j;
}
else i=p[i];
}