模式匹配

最新推荐文章于 2018-07-23 15:38:59 发布

原创最新推荐文章于 2018-07-23 15:38:59 发布 · 938 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#模式匹配 #BP算法 #KMP #KMP算法 #KMP算法证明

算法集锦专栏收录该内容

0 篇文章

订阅专栏

本文详细介绍了KMP算法，包括BF算法、KMP算法概述、next[]数组的定义及KMP算法正确性的数学证明，重点讨论了next[]数组在模式匹配中的作用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

模式匹配

欢迎转载，转载请注明原文链接：http://blog.youkuaiyun.com/lavor_zl/article/details/42805977

1.BF（Brute Force）算法

BF(Brute Force)算法是普通的模式匹配算法，BF算法的思想就是将目标串S的第一个字符与模式串T的第一个字符进行匹配，若相等，则继续比较S的第二个字符和 T的第二个字符；若不相等，则比较S的第二个字符和T的第一个字符，依次比较下去，直到得出最后的匹配结果。BF算法是一种蛮力算法。假设目标串S的长度为m,模式串的长度为n，那么BF算法的时间复杂度为O(mn)

算法实现：

int BFMatch(char targetStr[],char modelStr[])
{
	if(targetStr==NULL||targetStr[0]=='\0'||modelStr==NULL||modelStr[0]=='\0')
	{
		printf("目标串或模式串中有为空的或为空串的，此时无法模式匹配");
		return -1;
	}
	int i=0;//目标串的下标
	int j;//模式串的下标
	while(targetStr[i]!='\0')
	{
		j=0;
		while(modelStr[j]!='\0')
		{
			if(targetStr[i]==modelStr[j])
			{
				i++;
				j++;
			}
			else
			{
				/*
				可能有人开始时，不理解这里i是怎么回溯的，直观上我们只知道i要相对于本轮循环开始时的i加上1
				在本轮匹配的过程中j从0走到了现在的j，所走步数是现在的j，在回溯之前一直都是j走一步，i走一步，
				那么i走的步数也是现在的j,用现在的i减去现在的j就是原来的i即本轮循环开始时的i,再加上1就是回溯的下标i
				*/
				i=i-j+1;//回溯目标串的下标i
				break;
			}
		}
		//模式匹配成功，返回模式串在目标串中首次出现的位置
		if(modelStr[j]=='\0') return i-j;
	}
	return -1;//模式匹配失败，返回-1
}

2.KMP算法

2.1KMP算法概述

KMP算法是一种改进的字符串匹配算法，由D.E.Knuth与V.R.Pratt和J.H.Morris同时发现，因此人们称它为克努特——莫里斯——普拉特操作（简称KMP算法）。KMP算法的关键是利用匹配失败后的信息，尽量减少模式串与主串的匹配次数以达到快速匹配的目的。具体实现就是实现一个next()函数，函数本身包含了模式串的局部匹配信息。其实KMP算法与BF算法的区别就在于KMP算法巧妙的消除了指针i的回溯问题，只需确定下次匹配j的位置即可，使得问题的时间复杂度由O(mn)下降到O(m+n)。

2.2next[]数组

在KMP算法中，为了确定在匹配不成功时，下次匹配时j的位置，引入了next[]数组。
对于next[]数组的定义如下：
1) next[j] = -1 j = 0
2) next[j] = max(k) 0<k<j，P[0...k-1]=P[j-k,j-1]
3) next[j] = 0 其他

KMP算法的思想就是：在匹配过程称，若发生不匹配的情况，如果next[j]>=0，则目标串的指针i不变，将模式串的指针j移动到next[j]的位置继续进行匹配；若next[j]=-1，则将i右移1位，并将j置0，继续进行比较。

2.3KMP算法正确性的证明

网上很多讲解KMP算法的，甚至有的画图来演示KMP算法匹配的过程，但是他们往往忽略了一个重点，KMP算法的优点在于引进了next[]数组，那么我们重点就要关注next[]数组了，证明根据next[]数组移动指针的正确性。

很多求next[]的数组都给出上面的公式，那么请问第三项的条件其他是指那么条件？
这里的其他其实是指j=1或者j>1且不存在k,使得0<k<j，P[0...k-1]=P[j-k,j-1]

下面来证明next[]数组的正确性：

1) 若next[j] = -1 j = 0，则将i右移1位并将j置0

按照BF算法来回溯指针的话，应该令i=i-j+1，而此时j=0,所以i=i+1,即令i右移一位再重新和模式串进行匹配，那么就要将指针j置0。

2) next[j] = max(k) 0<k<j，T[0...k-1]=T[j-k...j-1]，则保持i不变，j变成next[j]即max(k)

保持i不变，j变成next[j]即max(k)然后继续进行模式匹配，那么指针i前面max(k)个字符一定与模式串中前max(k)个字符相等，此时是指针回溯到i-max(k)位置，然后与模式串比较前面max(k)个字符相等，所以指针又移动到了i位置。

按照BF算法，此时指针应该回溯到i-j+1位置。

①当max(k)=j-1时

指针回溯到了i-max(k)=i-(j-1)=i-j+1的位置，与BF算法相同，现在只需证明指针i前面max(k)个字符一定与模式串中前max(k)个字符相等。

因为目标串与模式串是比较到目标串指针i位置、模式串指针j位置，才确定本轮模式匹配失败的，那么指针i前面的j个字符一定与模式串中前j个字符相等，即S[i-max(k)...i-1]=T[0...j-1]

而T[0...k-1]=T[j-k...j-1]，k=max(k),那么T[0...max(k)-1]=T[j-max(k)...j-1]

又因为max(k)=j-1，所以T[0...max(k)-1]=T[1...max(k)]

由S[i-max(k)...i-1]=T[0...j-1]知,S[i-max(k)+1...i-1]=T[1...max(k)]

因为T[0...max(k)-1]=T[1...max(k)]，所以S[i-max(k)+1...i-1]=T[0...max(k)-1]，即指针i前面的max(k)个字符与模式串中前max(k)个字符相等。

②当max(k)<j-1时

指针回溯到了i-max(k)位置，没有按照BF算法回溯到i-j+1位置，那么说明指针回溯到i-j+1位置与i-max(k)-1位置之间，一定可以在目标串匹配到指针i位置的字符之前确定本轮模式匹配失败。

不妨设max(k)+1<=m<=j-1,那么只需证明在m的取值范围内，指针回溯到i-m，在目标串匹配到指针i位置的字符之前确定本轮模式匹配失败。

反证法：

假设指针回溯到i-m，在目标串匹配到指针i位置的字符之前还不能确定本轮模式匹配失败，那么指针i前面的m个字符一定与模式串中前m个字符相等，即S[i-m...i-1]=T[0...m-1]

因为目标串与模式串是比较到目标串指针i位置、模式串指针j位置，才确定本轮模式匹配失败的，那么指针i前面的j个字符一定与模式串中前j个字符相等，即S[i-max(k)...i-1]=T[0...j-1]，那么S[i-m...i-1]=T[j-m...j-1]

因为S[i-m...i-1]=T[0...m-1]，那么T[0...m-1]=T[j-m...j-1]

因为max(k)+1<=m，所以m>max(k)

又因为有前提条件next[j] = max(k) 0<k<j，T[0...k-1]=T[j-k...j-1]，

所以存在比原max(k)更大的值m使得0<m<j，T[0...m-1]=T[j-m...j-1]，与前提条件矛盾，所以假设不成立。

即指针回溯到i-j+1位置与i-max(k)-1位置之间，一定可以在目标串匹配到指针i位置的字符之前确定本轮模式匹配失败。

按照BF算法，指针回溯到i-j+1位置与i-max(k)-1位置之间，本轮模式匹配失败，那么指针回溯到i-max(k)位置继续进行下一轮模式匹配。此时指针回溯到i-max(k)位置,与BF算法相同。而现在指针保持i不变，j变成next[j]，那么指针i前面max(k)个字符一定与模式串中前max(k)个字符相等。

而T[0...k-1]=T[j-k...j-1]，k=max(k),那么T[0...max(k)-1]=T[j-max(k)...j-1]

又因为max(k)=j-1，所以T[0...max(k)-1]=T[1...max(k)]

由S[i-max(k)...i-1]=T[0...j-1]知,S[i-max(k)+1...i-1]=T[1...max(k)]

因为T[0...max(k)-1]=T[1...max(k)]，所以S[i-max(k)+1...i-1]=T[0...max(k)-1]，即指针i前面的max(k)个字符与模式串中前max(k)个字符相等。

3) next[j] = 0 其他，则保持i不变，j变成next[j]即0

①j=1时

按照BF算法指针应该回溯到i-j+1位置即i位置，因为本轮模式匹配失败，所以令j置0进行下一轮模式匹配，所以则保持i不变，j变成next[j]即0。

②j>1且不存在k,使得0<k<j，P[0...k-1]=P[j-k,j-1]，则保持i不变，j变成next[j]即0

因为模式匹配失败进行下一轮模式匹配都会令j置0，按照BF算法指针本该回溯到i-j+1，现在指针回溯到i，也就是说指针回溯到i-j+1到i-1之间一定在目标串匹配到指针i位置的字符之前确定本轮模式匹配失败。

不妨设1<=m<=j-1，那么只需证明在m的取值范围内，指针回溯到i-m，在目标串匹配到指针i位置的字符之前确定本轮模式匹配失败。

反证法：

因为目标串与模式串是比较到目标串指针i位置、模式串指针j位置，才确定本轮模式匹配失败的，那么指针i前面的j个字符一定与模式串中前j个字符相等，即S[i-m...i-1]=T[0...j-1]，那么S[i-m...i-1]=T[j-m...j-1]

又因为S[i-m...i-1]=T[0...m-1]，所以T[0...m-1]=T[j-m...j-1]与前提条件j>1且不存在k,使得0<k<j，P[0...k-1]=P[j-k,j-1]矛盾。因此假设不成立。

即指针i应该保持不变，j变成next[j]即0。

到此KMP算法就证明完毕了，这些都是根据自己的理解写的，可能还有一些纰漏之处，望大家多多包涵，有不对的地方还希望大家可以及时指出，不甚感激。

2.4算法求解next[]数组

//KMP算法求解next[]数组
int* next(char* modelStr)
{
	if(modelStr==NULL||modelStr[0]=='\0')
	{
		printf("模式串为空或空串，不存在next数组");
		return NULL;
	}
	int n=0;
	while(modelStr[n]!='\0')
	{
		n++;
	}
	int* next=(int*)malloc(sizeof(int)*n);
	next[0]=-1;
	if(modelStr[1]=='\0');//模式串中只有一个字符时
	else if(modelStr[2]=='\0') //模式串中只有两个字符时
	{
		next[1]=0;
	}
	else
	{
		next[1]=0;
		int *max=(int*)malloc(sizeof(int)*n);
	    maxK(modelStr,max);
	    int j=2;//只有j>=2时，才会next[j] = max(k): 0<k<j，P[0...k-1]=P[j-k,j-1]
		while(modelStr[j]!='\0')
		{
			next[j]=max[j];
			j++;
		}
	}
	return next;
}
//求模式串的next[]数组时，next[j] = max(k): 0<k<j，P[0...k-1]=P[j-k,j-1]的max(k)，不存在时返回0
void maxK(char* modelStr,int* maxK)
{
	int j=2;//只有j>=2时，max(k)才有可能存在
	while(modelStr[j]!='\0')
	{
		int i=0;
		int max=j-1;//max代表对应当前j的max(k)
		for(;i<max;i++)
		{
			if(modelStr[i]!=modelStr[j-max+i])
			{
				max--;
			}
			else
			{
				i++;
			}
		}
		maxK[j]=max;
		j++;
	}
}