[数据结构]KMP算法_kmp算法的next每次加1-CSDN博客

本文链接：https://blog.csdn.net/weixin_52377137/article/details/127112425

注意：日常数据结构题目问next数组的值，需要在此方法求出next基础上，全部加1

next数组（公式求，方便书写代码）

3、KMP算法优化（优化next数组）

next数组优化规则

1、暴力匹配（BF）算法

BF算法，即暴力 (Brute Force) 算法，是普通的模式匹配算法。

BF算法的思想就是将子串S 的第1个字符与主串T 的第1个字符进行匹配，若相等，则继续比较S的第2个字符和T的第2个字符；若不相等，则比较S的第1个字符和T的第二个字符。依次比较下去，直到得出最后的匹配结果。BF算法是一种蛮力算法。

例子，详细解释：

#include<stdio.h>
#include<string.h>

/*
字符串匹配算法 BF
str：主串
sub：子串
返回值：返回子串在主串当中的下标。如果不存在，则返回-1
*/
int BF(char *str, char *sub)
{
	if (str == NULL || sub == NULL)
		return -1;
	
	int lenStr = strlen(str);
	int lenSub = strlen(sub);
	int i = 0;
	int j = 0;

	while (i < lenStr && j < lenSub)
	{
		if (str[i] == sub[j])
		{
			i++;
			j++;
		}
		else
		{
			i = i - j + 1;
			j = 0;
		}
	}

	//执行到这说明，主串和子串肯定存在有执行完的情况
	if (j >= lenSub)//说明子串执行完
	{
		return i - j;
	}
	return -1;
}

int main()
{
	printf("%d\n", BF("ababcfabcde", "abcd"));//6
	printf("%d\n", BF("ababcfabcde", "abef"));//-1
	printf("%d\n", BF("ababcfabcde", "ab"));//0

	return 0;
}

2、KMP算法

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

KMP算法的时间复杂度O(m+n)

区别：KMP和BF唯一不一样的地方在，我主串的 i 并不会回退，并且 j 也不会移动到0号位置（目的）

具体例子解释：

此时str[i] != sub[j]，那么怎么办呢？（BF算法是此时 j 移动到 0 位置，i 移动到原下标的下一个位置，KMP算法该怎么做呢？）

我们发现，BF算法效率太低了（因为，i 移动到原下标的下一个位置，该位置的数是b，明显和子串a不符啊，所以产生一个优化的雏形：① i 回退位置是否能更高效？）。

由于此时 i 前面走过的元素，我们是已经知道了他们具体是哪些字符，而不再是未知区域。所以，我们能否 ② 利用好这块已知的区域？ --------> 产生KMP算法

可以发现，i 前面有a b ，是和子串中a b 是一致的，那能否 i 不动， j 移动到2位置呢？这样不就可以了吗省去不必要的比较了吗？

--------> 产生KMP算法思想： i 不回退，j 回退到一个特定的位置

所以，现在产生又一个疑问： j 应该如何确定回退的位置呢? 先不急解决这个问题，在此之前，理理上述思路：

本身 i 是不会回退的，所以，我们尽量在主串中找到和子串匹配的那部分串。

一旦str[i] != sub[j]，那么 j 就会回退到相应位置

可以发现，j 回退到相应位置，是需要特别标识记录的，那么就产生了一个KMP算法中的核心数组： next数组

next数组（手动求，方便求解题目）

作用：保存子串中的某个位置匹配失败后，应该回退的位置。

next数组

规则：找到匹配成功部分的两个相等的真子串（不包含本身），一个以下标0字符开始，另一个以 j-1 下标字符结尾。
不管什么数据，next[0] = -1； next[1] = 0；在这里，我们以下标来开始，而说到第几个第几个是从1开始。

next数组的作用清楚了，那么回到最初的遗留问题： j 应该如何确定回退的位置呢?

找法演示，验证规则（记~）

=======================================================================================

规则：找到匹配成功部分的两个相等的真子串（不包含本身），一个以下标0字符开始，另一个以 j-1 下标字符结尾。

=======================================================================================

此时 j 回退到2位置，2位置若和主串不匹配应该回退到哪？

====>

----------------------------------------------------
要找以sub[0]开始，
以sub[j-1]结尾的字符串，

在sub[0]~sub[j-1]中是否存在两个及以上？

----------------------------------------------------

如果至少存在两个，那么回退的位置数就为所有符合条件的字符串，最长字符串的长度
如果就存在一个，那么回退位置为0；

-----------------------------------------------------

即：a开始，b结尾的字符串在sub[0]~sub[j-1]中是否存在2个？

可以发现只有1个，那么next数组中2位置回退位置就为0；

----

那么next数组中的3位置应该回退到哪呢？

和上面一样的推理过程：

找以sub[0]开始，以sub[j-1]结尾的字符串在sub[0]~sub[j-1]中是否存在两个及以上？

即：a开始，c结尾的字符串在sub[0]~sub[j-1]中是否存在2个？

可以发现只有1个，那么next数组中3位置回退位置就为0；

----

那么next数组中的4位置应该回退到哪呢？

......找以a开始，以a结尾的字符串在sub[0]~sub[j-1]中是否存在2个？

可以发现，sub[0]~sub[0]、sub[3]~sub[3]是符合以a开始，以a结尾的字符串的，所以，存在两个字符串，那么回退的位置数就为字符串长度1（注意：sub[0]~sub[3]确实也是以a开始，以a结尾的字符串，但是只存在一个这样的串，不符合要求。所以，符合条件的字符串只有sub[0]~sub[0]、sub[3]~sub[3]，其长度就为最长字符串长度）【体会！】

----

那么next数组中的5位置应该回退到哪呢？

....找以a开始，以b结尾的字符串在sub[0]~sub[j-1]中是否存在2个？

可以发现，sub[0]~sub[1]、sub[3]~sub[4]是符合以a开始，以b结尾的字符串的，所以，存在两个字符串，那么回退的位置数就为字符串长度2

所以最终next数组为：

练习：

对" ababcabcdabcde "，求其的next数组
对" abcabcabcabcdabcde "，求其的next数组

答案：

--------------------------------------------------------------------------------------------------------------------

值得思考的两点

1.

2.

注意：日常数据结构题目问next数组的值，需要在此方法求出next基础上，全部加1

OK，到目前为止，KMP算法中我们知道了KMP算法的思想、为什么使用next数组(next数组的作用)、next数组的手动求法

那么在代码中怎么体现这种手动算的next数组呢？-----> 手算的这种方式在代码中的确不好实现（“ 剪不断，理还乱 ”）。写代码，next数组需要用公式求！

next数组（公式求，方便书写代码）

公式求，才能方便代码书写。

起始位置next[0] = -1; next[1] = 0; 那么知道了当前位置 i 处 next[i] = k; 如何通过当前 i 位置求出 i+1 位置呢？ （ next[i+1] = ? ）

代码实现

找漏补缺版本

//找漏补缺版本
//还没实现GetNext
#include<stdio.h>
#include<string.h>
#include<assert.h>
/*
KMP算法
str：主串
sub：子串
pos: 从子串的pos位置开始匹配
return：返回子串在主串当中的下标。如果不存在，则返回-1
*/
int KMP(char* str, char* sub, int pos)
{
	assert(str != NULL && sub != NULL);
	int lenStr = strlen(str);
	int lenSub = strlen(sub);
	if (lenStr == 0 || lenSub == 0) return -1;
	if (pos < 0 || pos >= lenStr) return -1;

	//next数组
	int* next = (int*)malloc(sizeof(int) * lenSub);
	GetNext(sub, next);

	int i = pos;//遍历主串
	int j = 0;//遍历子串

	while (i < lenStr && j < lenSub)
	{
		if (str[i] == sub[j])
		{
			i++;
			j++;
		}
		//一旦不匹配，就要使用到next数组来制定j的回退位置
		else
		{
			j = next[j];
		}
	}

	//执行到这说明，主串和子串肯定存在有执行完的情况
	if (j >= lenSub)//说明子串执行完
	{
		return i - j;
	}
	return -1;
}

上述代码问题：

GetNext怎么实现？

//next数组保存回退位置
void GetNext(char* sub, int* next, int lenSub)
{
	next[0] = -1;
	next[1] = 0;
	int i = 2;//当前i下标
	int k = 0;//前一项的k

	while (i <= lenSub)
	{
		if (k == -1 || sub[i - 1] == sub[k])
		{
			next[i] = k + 1;
			i++;
			k++;
		}
		else
		{
			k = next[k];
			next[i] = k + 1;
		}
	}
}

KMP算法

#include<stdio.h>
#include<string.h>
#include<assert.h>
#include<stdlib.h>
/*
KMP算法
str：主串
sub：子串
pos: 从子串的pos位置开始匹配
return：返回子串在主串当中的下标。如果不存在，则返回-1
*/
//next数组保存回退位置
void GetNext(char* sub, int* next, int lenSub)
{
	next[0] = -1;
	next[1] = 0;
	int i = 2;//当前i下标
	int k = 0;//前一项的k

	while (i <= lenSub)
	{
		if (k == -1 || sub[i - 1] == sub[k])
		{
			next[i] = k + 1;
			i++;
			k++;
		}
		else
		{
			k = next[k];
			next[i] = k + 1;
		}
	}
}
int KMP(char* str, char* sub, int pos)
{
	assert(str != NULL && sub != NULL);
	int lenStr = strlen(str);
	int lenSub = strlen(sub);
	if (lenStr == 0 || lenSub == 0) return -1;
	if (pos < 0 || pos >= lenStr) return -1;

	//next数组
	int* next = (int*)malloc(sizeof(int) * lenSub);
	GetNext(sub, next, lenSub);

	int i = pos;//遍历主串
	int j = 0;//遍历子串

	while (i < lenStr && j < lenSub)
	{
		if (j == -1 || str[i] == sub[j])
		{
			i++;
			j++;
		}
		//一旦不匹配，就要使用到next数组来制定j的回退位置
		else
		{
			j = next[j];
		}
	}

	//执行到这说明，主串和子串肯定存在有执行完的情况
	if (j >= lenSub)//说明子串执行完
	{
		return i - j;
	}
	return -1;
}

//int main()
//{
//	printf("%d\n", KMP("ababcfabcde", "abcd", 0));//6
//	printf("%d\n", KMP("ababcfabcde", "abef", 0));//-1
//	printf("%d\n", KMP("ababcfabcde", "ab", 0));//0
//
//	return 0;
//}