KMP算法(未完待续)
KMP算法由Knuth、Morris、Pratt三位前辈提出来的，取了这三个人的名字的头一个字母。
用途：用于处理字符串匹配，判断主串是否包含模式串。
举例：
匹配的结果：返回匹配的下标3
KMP思想：每当一趟匹配过程中出现字符比较不等时，不需回溯主串指针，而仅仅移动模式串，从而尽可能地减少比较次数。
与朴素方法的区别：
朴素方法：当匹配失败时，主串指针会回溯
Kmp算法：当匹配失败时，主串指针不会回溯
举例：使用模式串T去匹配主串S：
朴素的方法：
1、如图（1）所示，使用朴素方法匹配时，主串游标从i = 0开始匹配，第一趟要比较的字符区间为[0,7]。
在匹配的过程中，当主串游标 i = 5，模式串游标 j = 5 时，匹配失败。
2、如图（2）所示，匹配失败时，主串游标将从上一次匹配的起始点（i = 0）的下一位（i = 1）重新与模式串的起点（j = 0）开始匹配，即i将从i = 5退到i = 1，模式串游标j也从j = 5退到 j=0开始重新匹配，即主串和模式串都需要回溯。匹配过程一直执行到匹配成功或者主串遍历完毕为止。
时间复杂度：O（m*n），n表示主串长度，m表示模式串长度
缺点：在匹配不成功时，主串游标要回溯到上一次匹配起始点的下一位，模式串都要回到起点重新开始匹配。在这个过程中，其实做了不少重复的工作，造成时间上的浪费。
其实第二次匹配可以从（i = 5，j= 2）开始匹配。如图（3）所示。
为什么呢，这就是我们的KMP算法。
------------------------KMP算法-------------------------
KMP算法：
KMP算法和朴素算法最大的区别就是，每当匹配失败时，KMP算法不会回溯主串指针（i），而且也不一定每次都从模式串的起始位置进行匹配。
现在解释下，当第一次匹配失败时，KMP算法为什么会从图（3）这个状态开始匹配。
1、如图（4）所示，在第一次匹配失败时，主串和模式串的游标分别为（i = 5，j = 5）。
此时说明之前比较过的字符都是匹配的，即主串的[0,4]和模式串的[0,4]都是相等的。
此时可以进一步推出主串区间[3,4]和模式串区间[3,4]时匹配的，如图（5）所示。
2、如图（6）所示，对于模式串T，又因为区间[0,1]和区间[3,4]之间的字符相等。那么在下一次匹配时，模式串中区间[0,1]之间的字符就不用再与主串的区间[3,4]的字符匹配了，而直接让主串S上一次不匹配的位置（i=5）与区间[0,1]的下一个位置j=2开始匹配，这样就可以省去区间[0,1]之间的字符的比较。
3、即如图（7）所示，在第二次匹配时，主串从i=5，模式串从j=2开始匹配。
此时可以总结下，用KMP算法进行匹配时，主要的亮点是，当匹配失败时，主串游标i不动，模式串游标j尽可能远的往右移动，此时j之前的区间[0,j-1]不用比较，直接跳过去。
下面我们需要解决的问题是：当主串在第i个位置与模式串第j个位置匹配失败时，j的位置移动到哪里？
在上面的例子中，之所以模式串能在j = 2的位置比较，是因为我们事先假设知道：
（1）主串区间[0,4]和模式串区间[0,4]中的字符时相等的。
（2）模式串区间[0,1]和[3,4]中的字符时相等的。
对于（1），这两个区间的字符相等是肯定的。
原因是，我们之所以能对主串的第i个字符和模式串的第j个字符匹配，就是因为它们之前的j个字符（下标从0开始）肯定相等。
对于（2），如果不事先做一些预处理操作，是无法直接找到字符都相等的区间的。
此时我们的重点就是怎么寻找这个区间。
下面我们需要解决的问题是：当主串的第i个字符与模式串的第j个字符不匹配时，在模式串的字符区间[0，j-1]中，是否存在一个长度为t最大区间，使得模式串区间[0,t-1]和区间[j-t,j-1]中的字符相等？这里，t应该取相等区间的最大值长度。
举例：如图（8）所示，在j=5时，在区间[0,4]中，存在一个最大区间长度t =2，使得模式串区间[0,1]和模式串区间[3,4]之间的字符相等。
根据我们的观察可知，对于模式串T中的第j个字符，其区间t值的求解和主串没有关系。我们可以直接在模式串中找到一个最大t值，使得区间[0,t-1] 和 区间[j - t，j-1]中的字符相等即可。
为了在主串和模式串匹配过程中，对于模式串T中的每一个字符，都能直接其t值，我们可以预处理一个数组next数组来存储这个t值。
如果 next[j] = x 成立，则表示如果主串的第i个字符和模式串的第j个字符不匹配时，下次匹配是让主串的第i个字符和模式串的第x个字符开始匹配。
条件next[j] = x 还表示，对于模式串的第j个字符，如果存在一个最大区间t，使得模式串区间[0,t-1] 和 区间[j - t，j-1]中的字符相等。此时 x是等于 t （字符串下标从0开始）。即在进行下一次匹配时，可以把模式串区间[0,t-1]之间的字符不进行比较，略过这个区间，直接跳到下标为t个字符（第t+1个字符）进行比较。
代码：
int KMP(const char* strTarget,const char* strPattern,int next[])
{
assert(strTarget && strPattern);
int nCurTar = 0;
int nCurPat = 0;
int nTargetLen = strlen(strTarget);
int nPatternLen = strlen(strPattern);
while (nCurTar < nTargetLen && nCurPat < nPatternLen)
{
if (-1 == nCurPat || strTarget[nCurTar] == strPattern[nCurPat])
{
//模式串和主串指针均往前走，继续下一次匹配的情况有两种：
//1、主串第nCurTar个字符与模式串第nCurPat个字符相等，此时需要比较下一个字符
//2、模式串第nCurPat字符，不存在一个t值，满足要求，已经无路可退。此时主串从nCurTar开始的字符肯定不会与模式串匹配。
nCurTar++;
nCurPat++;
}
else
{
//主串第nCurTar个字符与模式串第nCurPat个字符不相等，此时模式串回溯到第next[nCurPat]进行匹配
nCurPat = next[nCurPat];
}
}
if (nCurPat == nPatternLen) //匹配成功
{
assert(nCurTar - nPatternLen >= 0);
return nCurTar - nPatternLen;
}
return -1;
}
注意：
初始化next数组
代码：
void GetNext(const char* strPattern,int next[])
{
assert(strPattern && next);
int nCurPat = 1;
int nLastPos = -1;
int nPatternLen = strlen(strPattern);
next[0] = -1;
while (nCurPat < nPatternLen)
{
if (-1 == nLastPos || strPattern[nCurPat - 1] == strPattern[nLastPos])
{
next[nCurPat] = ++nLastPos;
nCurPat++;
}
else
{
nLastPos = next[nLastPos];
}
}
}next数组的优化
void GetNext(const char* strPattern,int next[])
{
assert(strPattern && next);
int nCurPat = 1;
int nLastPos = -1;
int nPatternLen = strlen(strPattern);
next[0] = -1;
while (nCurPat < nPatternLen)
{
if (-1 == nLastPos || strPattern[nCurPat - 1] == strPattern[nLastPos])
{
++nLastPos;//此时，nLastPos与正在处理的字符匹配的位置，nCurPat指向目前正在处理的字符
if (strPattern[nCurPat] != strPattern[nLastPos])
{
next[nCurPat] = nLastPos;
}
else
{
next[nCurPat] = next[nLastPos];
}
++nCurPat;
}
else
{
nLastPos = next[nLastPos];
}
}
}
当模式串和主串不匹配时，模式串下一次比较的起始位置是需要在运行之前预处理得到。
在匹配之前，对模式串进行预处理。在匹配时，如果匹配失败，不用回过头重新比较主串中的字符（不用回溯主串的指针），而是利用部分匹配的结果和模式串的预处理信息，确定从模式串的哪一个字符重新开始比较，而尽可能地减少匹配次数。
如果我们找到这个t之后，当主串的第i个字符与模式串的第j个字符不匹配时，可以直接让主串的第i个字符与模式串的第t个字符开始匹配即可。
每当一趟匹配过程中出现字符比较不等时，不需回溯主串指针，而仅仅移动模式串，从而尽可能地减少比较次数。
而是利用已经得到的部分匹配的结果，将模式串向右滑动尽可能远的一段距离后，继续进行比较，而尽可能地减少比较次数。