kmp字符串匹配

字符串匹配kmp算法非常高效，朴素匹配算法的复杂度是O(n*m)，kmp的复杂度可以达到O(n + m)（n为模板的字符串长度，m为待匹配子串的长度）但是kmp算法理解起来还是需要一定的时间。

一. 求next数组

对于待匹配的字符串，求它的next并存储在数组中，也即各个长度前缀中前后相同的字符个数。

例子：

abccab

这个字符串的前缀有：a, ab, abc, abcc, abcca, abccab

前缀a中前后相同的字符个数为：0

前缀ab中前后相同的字符个数为：0

前缀abc中前后相同的字符个数为：0

前缀abcc中前后相同的字符个数为：0

前缀abcca中前后相同的字符个数为：1

前缀abccab中前后相同的字符个数为：2

二.next数组求解算法实现

例子：

ababcababde

按照前面介绍的方法，我们可以知道，前缀ababcabab，next[9] = 4

每次设置k = next[j]

当j = 9时, k = next[9] = 4,这个时候我们要求next[10]

我们可以看到，k = 4, 表明ababcabab (表明前后4个相同)，这个时候我们要求ababcababd的相同字符个数，只需要比较

ababcababd中的c和d是否相同，如果相同，直接可以得到，next[10] = next[9] + 1 = k + 1 = 5但是正如这个例子所显示的，c和d不相同，这个时候我们就需要找到前半部分abab中的匹配个数(在已经匹配的部分中找)，可以看到next[4] = 2, 即(abab的next数值为2)

这个时候，令k = next[k]

可以得到

a b a b c a b a b d

                     a b a(k = 2)， pattern[2] = a，这个时候比较pattern[k] = a与‘d'是否相同，如果不同，重复上面的步骤，即k = next[k]

三.进行字符串的匹配

当匹配不成功的时候只需要利用next数组从pattern的next[i]的位置进行比较即可，不需要从pattern[i]最开始的位置重新进行比较。

最后返回匹配成功的第一个子串的下标位置

四. 代码实现

#include <iostream>
#include <string.h>
#include <vector>
using namespace std;

// the next value of the total prefix is not used so can ignore it
void computeNext(int next[], string pattern) {
	int n = pattern.size();
	if (n == 0) return;
	int k = -1, j = 0;
	next[0] = -1;
	while (j < n) {
		if (k == -1 || pattern[k] == pattern[j]) {
			k++;
			j++;
			next[j] = k;
		} else {
			k = next[k];
		}
	}
}

int kmp(string str, string pattern, int next[]) {
	int strLen = str.size(), patLen = pattern.size();
	int posS = 0, posP = 0;
	while (posS < strLen && posP < patLen) {
		if (posP == -1 || str[posS] == pattern[posP]) {
			posP++;
			posS++;
		} else {
			posP = next[posP];
		}
	}
	if (posP < patLen) return -1;
	else return posS -patLen; 
}

int main() {
	string str;
	string pattern;
	getline(cin, str);
	getline(cin, pattern);
	int n = pattern.size();
	int next[n] = {0};
	
	computeNext(next, pattern);
	for (int i = 0; i < n; ++i)
		cout << next[i] << " ";
	cout << endl;

	int pos = kmp(str, pattern, next);
	cout << pos << endl;
	return 0;
}