【手把手带你学会KMP算法】

相信大家在遇到字符串匹配问题时,无论是听老师上课讲还是在网上查询资料时几乎都会用到KMP算法,本篇博客借鉴于大博哥对于KMP算法的分析以及自身对于KMP算法的看法,相信认真看完了后会对你有一些帮助。

 

目录

 1 BF 算法

2 KMP 算法

3 KMP算法的优化



 1 BF 算法

了解KMP算法之前,我们先来回忆一下BF算法(暴力求解),基本思想就是主串中元素与子串中元素一一比较,匹配失败就让子串返回到0下标,主串回溯到开始匹配的下一位。

假设主串的长度位M  子串的长度为N  BF算法的时间复杂度为 O(M*N)

 

动图详解(此图借鉴于其他博主):

【手把手带你学会KMP算法】_第1张图片

 

 具体代码:

int BF(char* mainStr, char* subStr,int pos)
{
	assert(mainStr && subStr);
	if (!*subStr)
	{
		return 0;
	}
	if (!*mainStr)
	{
		return -1;
	}

	int lenMain = strlen(mainStr);
	int lenSub = strlen(subStr);

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

	while (i < lenMain && j < lenSub)
	{
		if (mainStr[i] == subStr[j])
		{
			i++;
			j++;
		}
		else
		{
			i = i - j + 1;
			j = 0;
		}
	}

	if (j == lenSub)
	{
		return i-j;
	}
	else
	{
		return -1;
	}
}

2 KMP 算法

KMP算法的诞生:KMP算法是三位大牛:Knuth、Morris和Pratt同时发现的,于是取了他们名字的首字母然后组合起来,就成了该算法的命名。(来自百度)

 kmp算法的主要思想是:在主串中查找子串时,利用主串和子串中已经匹配的部分,跳过一些无用的比较,使主串的标记指针不会回溯,子串的标记指针移动。其实主要是子串中如果有部分内容和主串中一致,我们需要研究这些已知的匹配内容,这相当于我们需要研究子串,发现子串中存在的规律。KMP算法的时间复杂度为 O(M+N)

 听起来是不是有点懵,没关系,我们来举个栗子:

主串:ababcabcdabcde

子串:abcd

由上述主串与子串数据可知目前在索引为2匹配失败,就算让主串回退到1也是没有必要的,因为主串中1位置字符b与子串0位置的a也不一样,所以我们的目的是:主串是不回退的,让子串回退到特定的位置

那么子串应该回退到什么位置呢? 再来举个栗子:

主串:abcababcabc

子串:abcabc

这里主串与子串在索引为5的位置不匹配,由于主串不回退,回退的是子串,通过肉眼观察我们发现子串回退到索引为2是比较合理的(我们要尽量在主串中找到和子串匹配的一部分串),由于主串中索引为5的字符a!=子串中索引为2的字符c,所以还要继续回退,直到回退到与字符a相等为止。那如果字符数量多了用肉眼观察肯定是不切合实际的,所以我们引出了next数组,用来保存子串中某个位置匹配失败后回退的位置

KMP的精髓就是next数组,那么应该怎样来求next数组呢?假定next[j]=k;

求k的规则:

  1. 找到匹配成功部分的两个相等的真子串(不包含本身)一个以下标0开始,另一个以j-1下标结束
  2. 总有next[0]=-1,next[1]=0。

有了上面的规则我们就可以来求next数组了:

栗子1:“ababcabcdabcde"

它对应的next数组为:[-1,0,0,1,2,0,1,2,0,0,1,2,0,0]

栗子2:”abcabcabcabcdabcde"

它对应的next数组为:[-1,0,0,0,1,2,3,4,5,6,7,8,9,0,1,2,3,0]

通过上面的栗子我们可以得出总结:找的时候可以找重复的,但是必须是以0下标开始,找的前一位下标结束;而且数组中元素增大只能一个一个的加,减小可以跳跃减小。

到这里我相信大家对求next数组应该没有什么问题了。但现在的问题是我们如何用公式来求next数组,总不能next数组让我们人为来算,这显然是不现实的。

我们假设已知:next[i]=k;

                                     k            i

给定一个字符串" a b c a b a b c a b c "

                           0 1 2 3 4 5 6 7 8 9 10

next数组:          [-1,0,0,0,1,2,1,2,3,4,5]

我们假设此时i==8

则我们可以知道:p[0]……p[k-1] == p[i-k]……p[i-1]

所以由:next[i]=k  <--->   p[0]……p[k-1] == p[i-k]……p[i-1]

如果现在 p[k]==p[i]  将其分别加在上式右边的两边得:

p[0]……p[k] == p[i-k]……p[i]

所以不难推出:next[i+1]=k+1;这也很好得解释了为什么增加只能一个一个的加。

那么问题又来了,如果p[k] != p[i]呢?

假设索引为8的元素由a改为b,那么k就要回退到next[k]的位置,也就是k=0,但还是不满足p[k]==p[i],就继续回退k=-1,此时已经找不到了,就直接将0给予给下一位,也就是:

next[i+1]=0;

 

 好了,next数组的求解概念已经掌握,现在我们如何用代码来将其表示出来呢?

代码的具体实现:

int KMP(char* mainStr, char* subStr, int pos)
{
	assert(mainStr && subStr);
	if (!*subStr)
	{
		return 0;
	}
	if (!*mainStr)
	{
		return -1;
	}

	int lenMain = strlen(mainStr);
	int lenSub = strlen(subStr);
	//动态申请next数组
	int* next = (int*)malloc(sizeof(int) * lenSub);
	if (NULL == next)
	{
		exit(-1);
	}
	GetNext(next,subStr);

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

	while (i < lenMain && j < lenSub)
	{
		if (mainStr[i] == subStr[j] || -1==j)
		{
			i++;
			j++;
		}
		else
		{
			j = next[j];
		}
	}

	if (j == lenSub)
	{
		free(next);
		return i - j;
	}
	else
	{
		free(next);
		return -1;
	}

}

这里面有一个容易出错的点,当j==-1时也不要忘记了处理,当j==-1时说明回到了索引为0的位置,并且还没有找到与其匹配的项,就让j从索引为0开始与i一一比对。

得到next数组的具体代码:

void GetNext(int* next, int* subStr)
{
	assert(next && subStr);
	int lenSub = strlen(subStr);
	next[0] = -1;
	next[1] = 0;
	int i = 2;
	int k = 0;

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

由于这里的next[i]是未知的,而next[i-1]才是已知的,所以上面才是subStr[i - 1] == subStr[k]

next[i] = k + 1; 同理当k==-1时说明到索引为0都还没有匹配的项就把其置为0.

 


3 KMP算法的优化

假定给一个这样的字符串: " a a a a a a a a a a g "

它的next数组为:               [-1,0,1,2,3,4,5,6,7,8,9]      

 假设在索引为9的位置匹配失败,则j会不断回退直到j==-1,这样效率就比较低了,有什么办法能够一步到位回退呢?

我们不妨优化一下next数组:为了区别,不妨将将优化后的数组取名为nextval

nextval数组的规则如下:

1 如果回退到的位置和当前字符一样,就写回退那个位置的nextval值;

2 如果回退到的位置和当前字符不一样,就写当前原来的nextval值;

 举个栗子:给" a  b  c  a  a  b  b  c  a  b  c  a  a  b  d  a  b "

next:               [-1, 0, 0, 0, 1, 1, 2, 0, 0, 1, 2, 3, 4, 5, 6, 0,1]

nextval:          [-1, 0, 0,-1, 1, 0, 2, 0,-1, 0, 0,-1, 1, 0, 6,-1,0]

具体代码:

void GetNextval(int* nextval, int* subStr)
{
	assert(nextval && subStr);
	int lenSub = strlen(subStr);
	nextval[0] = -1;
	nextval[1] = 0;
	int i = 2;
	int k = 0;

	while (i < lenSub)
	{
		if ((-1 == k) || subStr[i - 1] == subStr[k])
		{
			nextval[i] = k + 1;
			i++;
			k++;
		}
		else
		{
			k = nextval[k];
		}
	}
	i = 2;
	while (i < lenSub)
	{
		if (subStr[i] == subStr[nextval[i]])
		{
			nextval[i] = nextval[nextval[i]];
		}
		i++;
	}
}

好了,KMP算法就到这里了,如果有什么不对的地方欢迎各位佬在评论区指正。

【手把手带你学会KMP算法】_第2张图片

 

你可能感兴趣的:(c语言,KMP算法)