串的模式匹配（简单匹配、KMP以及手工算next/nextval)

简单模式匹配

        思路：主串和字串进行匹配，设置i、j、k（主串、子串和匹配起始下标）主串和子串一开始都是从第一个位置（k = i），若当前主串和子串匹配成功那么i++、j++，若匹配不成功k++、j = 1，i = k(主串从上次匹配的下一个开始，子串回到第一个字符)重复以上步骤。若是匹配成功，则返回子串在主串中的位置（k)，若是匹配不成功，则返回一个可以区别于主串所有标记的位置，比如 0.

#include<iostream>
#include<string>
using namespace std;
/*
思路：主串和字串进行匹配，设置i、j、k（主串、子串和匹配起始下标）
主串和子串一开始都是从第一个位置（k = i），若当前主串和子串匹配成功那么i++、j++，
若匹配不成功k++、j = 1，i = k(主串从上次匹配的下一个开始，子串回到第一个字符)
重复以上步骤。若是匹配成功，则返回子串在主串中的位置（k)，若是匹配不成功，
则返回一个可以区别于主串所有标记的位置，比如 0.
*/
int index(string str, string substr) {
	int i = 1, j = 1, k = i; // 这里规定字符串从第一个开始，比较好操作
	if (str.length() == 1 || substr.length() == 1) return 0;// 主串或者子串为空的情况下
	while (i < str.length() && j < substr.length()) { // i,j都没有遍历到结尾
		if (str[i] == str[j]) { // 若匹配
			i++;
			j++;
		}
		else { // 若不匹配
			k++;
			j = 1;
			i = k;
		}
	}
	if (j > substr.length()) { // 匹配成功
		return k;
	}
	return 0;
}

KMP匹配

简单匹配的缺点

        KMP与简单匹配的区别在于如何利用已知且匹配好的模式串，简单匹配每当匹配到不匹配的位置时一律将 i 赋值为 i - j + 2 ，j 赋值为 1。这样的坏处就在于①不匹配的地方不被解决②不匹配的地方任然存在。显然这样暴力求解的方法简单但不高效。

KMP匹配思想

        KMP关键在于如何利用已知已匹配成功的部分模式串，而主串是何种形式并不关心。KMP模式匹配中每当遇到不匹配的位置，我们往前看以匹配好的部分串，如果以匹配成功的模式串的部分串中，存在与不匹配位置（不匹配位置前面）相等的后缀，那么我们就移动模式串（难以理解，看下图）

        假设模式串从第一个字符到不匹配的字符之前的部分串为 F 而 与不匹配位置开始的前缀为 G，与 G 匹配相等的模式串某后缀为 H ，我们要做的就是将 F 后移直到 G 与 H 重合，H 的下一个位置则为模式串需要跳转比较的新位置，为了记录这些新位置我们引入 next[]数组以记录发生不匹配的情况时 j 跳转的位置。

手工算next数组

        说明第一个位置（特殊情况一）不匹配时，i 赋值为 0，j 赋值为 0，然后 i++, j++;

        第二个位置不匹配时（特殊情况二），i 保持不变，j = 1，然后 i++, j++；

直到最后 j > substr.length() 退出循环。

另一个例子如下：

        参照以上方法，写下一下例子的答案：

KMP实现代码

#include<iostream>
#include<string>
using namespace std;

// 获取next数组
void getNext(string substr, int next[]) {	
	int i = 1, j = 0; // 模式串从第一个字符串开始，数组下标从 1 开始
	next[1] = 0;
	while (i <= substr.length()) {// 取到最后一个串
		if (j == 0 || substr[i] == substr[j]) { // j退回到0时，和 i 一起向后移
			++i;
			++j;
			next[i] = j;
		}
		else {
			j = next[j];
		}
	} 
}

int KMP(string str, string substr, int next[]) {
	// 先获取模式串
	getNext(substr, next);
	int i = 1, j = 1; // 模式串从0开始
	if (str.length() == 1 || substr.length() == 1) return 0;// 主串或者子串为空的情况下
	while (i <= str.length() && j <= substr.length()) {
		if (j == 0 ||str[i] == substr[j]) { // 若匹配成功
			i++;
			j++;
		}
		else {
			j = next[j];
		}
	}
	if (j > substr.length()) { // 匹配成功
		return i - substr.length(); // 返回匹配的初始位置
	}
	return 0;
}

进一步的KMP匹配

        观察以上手工算next数组的第一个例子，我们会发现当发生不匹配的字符与 next 数组所指的字符相同时，跳转后不匹配仍然存在，且后续还需要跳转，这样就需要跳转两次。那我们能不能只跳转一次呢？这样就引入了nextval 数组，nextval 数组的引入是为了解决上述现象，使得KMP匹配算法更加高效，那么如何计算 nextval 数组呢？看下图👇

👆的例子有点特殊，我们看另一个例子👇

        总之：nextval 数组计算的一般规律是，在计算出 next 数组之后，观察当前 next 和需要跳转的下一个位置的所对应的字符是否相等，若相等那么 nextval[j]等于需要跳转后的那个位置的 next 值（结合上面的例子看），若不相等那么 nextval[j]= next[j]的值.

改进KMP代码

#include<iostream>
#include<string>
using namespace std;

void getNextval(string substr, int nextval[]) {
	
	if (substr.length() == 1) return; // 主串或者子串为空的情况下
	int i = 1, j = 1; // nextvl也是从1开始
	nextval[1] = 0; // 特殊位置
	while (i <= substr.length()) {
		if (j == 0 || substr[i] == substr[j]) {
			++i; ++j;
			if (nextval[i] != nextval[j]) { // i、j处字符不相等
				nextval[i] = j; // 当前需要跳转的位置
			}
			else {// i 、j所指字符相等
				nextval[i] = nextval[j]; // 需要跳转后位置的跳转位置
			}
		}
	}
}