KMP算法利用匹配失败后的信息，尽量减少模式串与主串的匹配次数以达到快速匹配的目的。具体实现就是实现一个next()函数，函数本身包含了模式串的局部匹配信息。时间复杂度O(m+n)。
Next()函数的详解
- 把将要进行next计算的字符串S分成 k ，j 前后两串，k代表前串开头所在的序号，j代表后串开头所在的序号，起始的时候j=1，k=0。
- 我们比较一下前串 后串是否相等，要怎么比较呢，肯定是比较S[j]==S[k],如果相等，那么next[j+1]=k+1，然后j++，k++。关键就是理解这个next[j+1]=k+1（为什么k+1？）：简单说就是S串中的第j+1个字符的next函数值由他前面的字符与前串相等的个数来决定，就是说串中的第j+1个字符的next函数值，是由他前面的字符串决定的。
- 当S[j]！=S[k],即不相等的时侯，那么j不动，k返回到开头（因该是next[k]位置，便于理解先假设是返回k=0处），即从头比较S[0]与S[j]，S[1]与S[j+1]。
例如：第 j+1 个字符的next函数值next[j+1]等于3，意味着它的前三个字符串，S[j-2]S[j-1]S[j] =S[0]S[1]S[2]。
例一：模式串：abcaabcba
|
下标 |
0 |
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
|
模式串 |
a |
b |
c |
a |
a |
b |
c |
b |
a |
|
next值 |
-1 |
0 |
0 |
0 |
1 |
1 |
2 |
3 |
0 |
1.第一个字符的next值令为-1。令第二个字符b的next值为0。初始k=0，j=1。开始比较S[k] 和S[j]。
2.比较S[0] !=S[1]，所以j++，k不变，next[j=2]=k=0。
3.比较S[0] !=S[2]，所以j++，k不变，next[j=3]=k=0。
4.比较S[0]==S[3]，所以j++，k++，next[j=4]=k=1。
5.k=1了，所以比较S[1] !=S[4]，k返回到next[k]位置，即k=next[1]=0，然后比较S[k=0] == S[4]，所以 j++，k++，next[j=5]=k=1。
6.比较S[1]==S[5]，所以j++，k++，next[6]=k=2。
7.比较S[2]==S[6]，所以j++，k++，next[7]=k=3。
8.比较S[3] !=S[7]，所以k返回到next[k=3]位置，即k=next[3]=0，然后比较S[k=0] !=S[7]，所以j++，k=0不变，next[8]=k=0。
在例一中，每次不相等时返回的都是k=next[k]=0，都是返回到了开头，下面一个不是返回到开头0的情况：
例二：模式串：aabcaaabaac
|
下标 |
0 |
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
|
模式串 |
a |
a |
b |
c |
a |
a |
a |
b |
a |
a |
c |
|
next值 |
-1 |
0 |
1 |
0 |
0 |
1 |
2 |
2 |
3 |
1 |
2 |
从 j=5，k=1的时候开始
5．比较S[1]==S[5]，所以j++，k++，next[j=6]=k=2。
6．比较S[2] !=S[6]，所以k返回到next[k=2]位置，即k=next[2]=1,然后比较S[k=1]==S[6]，所以 j++，k++，next[7]=k=2。
……
因此，发现K的退回是退回到next[k]的位置，即S[j]!=S[k]时，k=next[k]。
KMP的算法思想
和BF算法相比，KMP算法主要是在模式串上下功夫，通过先求得模式串对应的next[ ]数组，当两个字符串中字符匹配失败时候将模式串的下标回溯到next[ ]中存储的下标位置，而BF算法是直接回溯到模式串的0下标，即开始第一个字符。所以KMP算法的时间复杂度要比BF算法好。
KMP算法代码
#include<stdio.h>
#include<string.h> char* s = "aabcaaabaac";
char* t = "aac"; int next[]; //定义next数组 void getNext(char *s, int next[])
{
int k=-; / /k代表前串起始位置
int j=; //后串起始位置，一直增加
next[] = -; //令第一个字符的next值为-1 while(j < strlen(s) - ) //当后串小于最大下标-1
{
if(k == - || s[j] == s[k]) //匹配的情况下,即s[j]==s[k]，next[j+1]=k+1;
{
++j;
++k;
next[j] = k;
}
else //若不匹配，即p[j]!=p[k]，k=next[k]
k = next[k];
}
} int KMP(char* s, char* t)
{
int i = ; //i从s串开始
int j = ; //j从t串开始
int sLength = strlen(s); //s串的长度
int tLength = strlen(t); //t串的长度
while((i < sLength) && (j < tLength)) //当下标i和j都不越界时
{
if(j == - || s[i] == t[j]) //当模式串t中第一个字符与目标串s中某个字符匹配失败时，i应该移动到目标串s的下一个目标，再和模式串t的第一个字符进行比较，或者s的第i个字符和t的第j个字符相等，则将i++和j++
{
i++;
j++;
}
else
{
//i=i-j+1;j=0; //这是普通的BF算法,将模式串的下标从0开始
j = next[j]; //KMP算法是将模式串的j下标从next[j]开始
}
}
if(j >= tLength)
return i - tLength;
else
return ;
} int main()
{
getNext(s, next);
printf("%d", + KMP(s, t));
return ;
}