模式匹配算法：KMP算法

一.基本概念：

真前缀指的是除了本身以外字符串全部头部的组合，真后缀指的是除了本身以外字符串全部尾部的组合。

二.简单的模式匹配算法

按照正常的思维，字符串可以进行暴力匹配，代码如下。

int index_BF(string s,string p){
	int i = 0;
	int j = 0;
	int s_len = s.size();
	int p_len = p.size();
	while(i < s_len && j < p_len){
		if(s[i] == p[i]){
			i++;
			j++;
		}
		else{
			i = i-j+1;
			j = 0;
		}
	}
	if(j == p_len){
		return i-j;
	}
	else
	return -1;
}

暴力匹配的时间复杂度为O（mn），在处理大字符串很难满足我们的需求。

因此接下来介绍KMP算法，时间复杂度为O（m+n）。

三.KMP算法

3.1算法流程

摘自博客https://segmentfault.com/a/1190000008575379

（1）

首先，主串"BBC ABCDAB ABCDABCDABDE"的第一个字符与模式串"ABCDABD"的第一个字符，进行比较。因为B与A不匹配，所以模式串后移一位。

（2）

因为B与A又不匹配，模式串再往后移。

（3）

就这样，直到主串有一个字符，与模式串的第一个字符相同为止。

（4）

接着比较主串和模式串的下一个字符，还是相同。

（5）

直到主串有一个字符，与模式串对应的字符不相同为止。

（6）

这时，最自然的反应是，将模式串整个后移一位，再从头逐个比较。这样做虽然可行，但是效率很差，因为你要把"搜索位置"移到已经比较过的位置，重比一遍。

（7）

一个基本事实是，当空格与D不匹配时，你其实是已经知道前面六个字符是"ABCDAB"。KMP算法的想法是，设法利用这个已知信息，不要把"搜索位置"移回已经比较过的位置，而是继续把它向后移，这样就提高了效率。

（8）

i	0	1	2	3	4	5	6	7
模式串	A	B	C	D	A	B	D	'\0'
next[i]	-1	0	0	0	0	1	2	0

怎么做到这一点呢？可以针对模式串，设置一个跳转数组int next[]，这个数组是怎么计算出来的，后面再介绍，这里只要会用就可以了。

（9）

已知空格与D不匹配时，前面六个字符"ABCDAB"是匹配的。根据跳转数组可知，不匹配处D的next值为2，因此接下来从模式串下标为2的位置开始匹配。

（10）

因为空格与Ｃ不匹配，C处的next值为0，因此接下来模式串从下标为0处开始匹配。

（11）

因为空格与A不匹配，此处next值为-1，表示模式串的第一个字符就不匹配，那么直接往后移一位。

（12）

逐位比较，直到发现C与D不匹配。于是，下一步从下标为2的地方开始匹配。

（13）

逐位比较，直到模式串的最后一位，发现完全匹配，于是搜索完成。

3.2获得next数组

//得到next数组 
void getNext(string p,int next[]){
	int p_len = p.size();
	int i = 0,j = -1;
	next[0] = -1;
	while(i < p_len){
		if(j == -1 || p[i] == p[j]){
			i++;
			j++;
			//[0,j-1]和[i-j,i-1]相同的真前后缀 
			next[i] = j;
		}
		else{
			//如果不相同则是[0,j-1]相同的真前后长度
			j = next[j];
		}
	}
}

3.3KMP完整代码

#include <iostream>
#include<iomanip>
#include<cstring>

using namespace std;

const int N = 1005;

//得到next数组 
void getNext(string p,int next[]){
	int p_len = p.size();
	int i = 0,j = -1;
	next[0] = -1;
	while(i < p_len){
		if(j == -1 || p[i] == p[j]){
			i++;
			j++;
			//[0,j-1]和[i-j,i-1]相同的真前后缀 
			next[i] = j;
		}
		else{
			//如果不相同则是[0,j-1]相同的真前后长度
			j = next[j];
		}
	}
}

int KMP(string s,string p,int next[]){
	getNext(p,next);
	int i = 0;
	int j = 0;
	int s_len = s.size(),p_len = p.size();
	while(i < s_len && j < p_len){
		if(j == -1 || s[i] == p[j]){
			i++;
			j++;
		}
		else{
			j = next[j];
		}
	}
	if(j == p_len){
		return i-j;
	}
	else{
		return -1;
	}
}

int main(){
	ios::sync_with_stdio(false);
	cin.tie(0);
	int next[100] = {0};
	cout<<KMP("ababcabcacbab","abcac",next)<<endl;;
	return 0;

最后限于本人今天还有一丢丢事情没做，以及KMP优化算法的一些些的小缺陷，就先写到这。

参考：https://segmentfault.com/a/1190000008575379