KMP算法（next数组求法）

一、KMP概述

KMP算法是一种改进的字符串匹配算法，由D.E.Knuth，J.H.Morris和V.R.Pratt提出的，因此人们称它为克努特—莫里斯—普拉特操作（简称KMP算法）。KMP算法的核心是利用匹配失败后的信息，尽量减少模式串与主串的匹配次数以达到快速匹配的目的。具体实现就是通过一个next()函数实现，函数本身包含了模式串的局部匹配信息。KMP算法的时间复杂度O(m+n)。

二、next数组求解

如图为字符串ch：next[j] = k；那么next[j + 1] = ?。
分两种情况进行讨论：

• 第一种情况：ch[j] = ch[k]
  这种情况最简单，next[j + 1] = next[j] + 1。
  很好理解，第 j 个字符之前，能够相匹配的最长的前缀和后缀的长度是 k - 1，则next[j] = k，因为前 k - 1个字符一定是能够配对的，我们在进行再下一次模式匹配的时候，只需要从模式串的第 k 个字符开始。
  现在又已知ch[j] = ch[k]，则第j + 1个字符之前，能够进行配对的前缀和后缀中，长度最大的串的长度就是 (k - 1) + 1 = k，同理 next[j + 1] = k + 1 = next[j] + 1。
• 第二种情况：ch[j] != ch[k]
  我们的解决思路是：

1. 首先找到在第 j 个字符之前，第二长的能够匹配的前缀和后缀。
   先说结论，第二长的能够配对的前缀和后缀的长度是：next[next[j]] - 1。
   为什么呢？如图，设子串 a d 为所谓的第二长的前缀和后缀，a 一定包含在最长的前缀中，d 一定包含在最长的后缀中，我们也一定能够在最长的前缀中找到一个子串 b ，满足 b = d（原因很简单，最长的前缀和后缀是相等的），也就可以得到子串 a = b，很巧，子串 a b 如果相等，那就是第 k 个字符之前的串中，相匹配的前缀和后缀，所以问题就从找第 j 个字符前第二长的相匹配的前缀和后缀，转化为了找第 k 个字符前最长的相匹配的前缀和后缀，所以第 j 个字符之前，第二长的相匹配的前缀和后缀的长度就是 next[k] - 1，而 k = next[j]，所以是next[next[j]] - 1.
2. 之后我们看 ch[next[next[j]]] 和 ch[j]是否相等，如果相等，重复第一种情况，如果不相等，重复第二种情况。

求next数组代码：

//next数组
int* get_next(SString T)
{
	int len = T.length;            //字符串的长度
	int* next = new int[len + 1];  //定义next数组
	next[1] = 0;
	next[2] = 1;                   //前两个值无脑写 0 和 1

	//计算第3及之后字符对应的的next值
	for (int j = 3; j <= len; j++)
	{
		int k = next[j - 1];       //第i - 1个字符对应的next值

		//寻找相匹配的前缀和后缀
		while (k != 0)
		{
			//情况一，第 j 个字符和第 k - 1 个字符相等
			if (T.ch[k] == T.ch[j - 1])
			{
				next[j] = k + 1;
				break;
			}
			//情况二，第 j 个字符和第 k - 1 个字符不相等
			else
			{
				k = next[k];
			}
		}
		//没有相匹配的前缀和后缀，模式串指针回到第一个字符
		if (k == 0)
			next[j] = 1;
	}
	return next;
}

全部代码：

#include<iostream>
using namespace std;

#define MaxSize 10
//穿的顺序存储
struct SString {
	char ch[MaxSize + 1];  //静态数组
	int length;        //串的实际长度
};

//初始化操作
bool InitString(SString& S)
{
	S.length = 0;      //一开始，串的长度是0
	S.ch[0] = '#';
	return 0;
}

//赋值操作
bool StrAssign(SString& S, char ch[])
{
	//判断串是不是达到了最大长度
	int len = strlen(ch);
	int Slen = S.length;
	if (Slen + len > MaxSize)
		return false;
	for (int i = Slen + 1; i < Slen + len + 1; i++)
	{
		S.ch[i] = ch[i - Slen - 1];
		S.length++;
	}
	return true;
}


//next数组
int* get_next(SString T)
{
	int len = T.length;            //字符串的长度
	int* next = new int[len + 1];  //定义next数组
	next[1] = 0;
	next[2] = 1;                   //前两个值无脑写 0 和 1

	//计算第3及之后字符对应的的next值
	for (int j = 3; j <= len; j++)
	{
		int k = next[j - 1];       //第i - 1个字符对应的next值

		//寻找相匹配的前缀和后缀
		while (k != 0)
		{
			//情况一，第 j 个字符和第 k - 1 个字符相等
			if (T.ch[k] == T.ch[j - 1])
			{
				next[j] = k + 1;
				break;
			}
			//情况二，第 j 个字符和第 k - 1 个字符不相等
			else
			{
				k = next[k];
			}
		}
		//没有相匹配的前缀和后缀，模式串指针回到第一个字符
		if (k == 0)
			next[j] = 1;
	}
	return next;
}

//KMP算法
int Index_KMP(SString& S,SString T,int next[])
{
	int i = 1, j = 1;
	while (i <= S.length && j <= T.length)
	{
		//当前字符匹配或者是当前不匹配的字符是第一个字符
		if (j == 0 || S.ch[i] == T.ch[j])
		{
			i++;
			j++;
		}
		//当前字符不匹配，而且不是第一个字符，只需要修改模式串的指针
		else
		{
			j = next[j];
		}
	}
	if (j > T.length)
		return i - T.length;
	else
		return 0;
}



int main()
{
	SString T;
	InitString(T);
	char ch[] = "abcabcd";
	StrAssign(T, ch);
	int* next = get_next(T);
	for (int i = 1; i <= T.length; i++)
	{
		cout << next[i] << endl;
	}


	system("pause");
	return 0;
}

输入：

abcabcd

结果：

0
1
1
1
2
3
4

三、next数组优化

如图，当在模式串的第2个位置匹配失败的时候，由next数组可知，第二次匹配将从第1个位置开始匹配，但是存在一个问题，这两个位置的字符都是 a ，所以第2次匹配必然是失败的，所以我们直接跳过这个步骤，让模式串的指针 j 指向在第1个位置匹配失败的情况下，应该指向的位置0；当在第3个位置匹配失败的情况下，按照原先的next数组，模式串的指针应该指向第2个位置，同样，这两个位置相同，下次匹配必然失败，所以我们也跳过这个步骤，指针 j 指向在第 2 个位置匹配失败的情况下应该指向的位置，这个时候，next[2] = 0，所以next[3] = next[2] = 0，以此类推。

• next数组优化代码：

//next数组优化nextval数组
int* get_nextval(SString T, int next[])
{
	int* nextval = new int[T.length + 1];
	for (int j = 1; j <= T.length; j++)
	{
		nextval[j] = next[j];
		while (nextval[j] != 0 && T.ch[j] == T.ch[nextval[j]])
		{
			nextval[j] = nextval[nextval[j]];
		}
	}
	return nextval;
}