串的匹配：朴素匹配&KMP算法

Posted 2020-09-14 mthoutai

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了串的匹配：朴素匹配&KMP算法相关的知识，希望对你有一定的参考价值。

引言

字符串的模式匹配是一种经常使用的操作。

模式匹配(pattern matching)，简单讲就是在文本(text，或者说母串str)中寻找一给定的模式(pattern)。通常文本都非常大。而模式则比較短小。典型的样例如文本编辑和DNA分析。

在进行文本编辑时，文本一般是一段话或一篇文章，而模式则经常是一个单词。若是对某个指定单词进行替换操作，则要在整篇文章中进行匹配，效率要求肯定是非常高的。

模式匹配的朴素算法

最简单也最easy想到的是朴素匹配。何为朴素匹配，简单讲就是把模式串跟母串从左向右或从右向左一点一点比較：先把模式串的第一个字符同母串的第一个字符比較，若相等则接着比較后面的相应字符。若不等。把模式串后移一个位置，再次从模式串的头部比較……

这如同枚举法：把母串中与模式串同样长度的子串挨个比較。则这样的匹配方式显然无不论什么启示性或智能性。

例如以下图：

技术分享

以上步骤非常easy看懂。它的代码也各种各样，以下是当中一种：

/*
朴素的模式匹配算法，匹配方向：从前往后
匹配成功，则返回匹配成功时主串的下标位置(仅仅返回第一次匹配成功的位置)
否则，返回-1
母串或子串有一个为空也返回-1
*/
int naiveStringMatching(const char* T, const char* P)
{
	if (T && P)
	{
		int i, j, lenT, lenP;
		lenT = strlen(T);
		lenP = strlen(P);
		//模式串的长度比主串还长，显然无法匹配
		if (lenP > lenT)
			return -1;
		i = 0;
		while (i <= lenT-lenP)
		{
			j = 0;
			if (T[i] == P[j])
			{
				j++;
				//指针的写法是这种：while(j < lenP && *(T + i + j) == *P(j))j++;
				while (j < lenP && T[i + j] == P[j])
					j++;
				//顺利匹配到了模式串的结尾，则匹配成功
				if (j == lenP)
					return i;
			}
			i++;
		}
		//假设程序执行到这里，仍然没有结束，说明没有匹配上
		return -1;
	}
	return -1;
}

考虑到有时须要使用c++中的string类型，这时它的代码是这种：

int naiveStringMatching(const string T, const string P)
{
	int i, j, lenT, lenP;
	lenT = T.length();
	lenP = P.length();
	//串空或模式串的长度比主串还长，显然无法匹配
	if (lenT == 0 || lenP == 0 || lenP > lenT)
		return -1;
	i = 0;
	while (i <= lenT - lenP)
	{
		j = 0;
		if (T[i] == P[j])
		{
			j++;
			while (j < lenP && T[i + j] == P[j])
				j++;
			if (j == lenP)
				return i;
		}
		i++;
	}
	return -1;
}

不要小看上面的代码。尽管效率不高，但仍有掌握的必要。代码和算法总是在不断优化的，而这一切的优化都是从简单的情形開始的。

朴素匹配的时间复杂度是非常easy分析的。若是成功匹配。最好的情况下，第一次比較就匹配上了，此时仅仅需strlen(P)次(模式串的长度次)比較。最坏的情况下，一直须要比較到母串最后一个长度与模式串同样的子串。共(strlen(T)-strlen(P)+1)*strlen(P)次比較。平均下是O(strlen(T)*strlen(P))。

KMP算法

KMP算法是一种用于字符串匹配的算法,这个算法的高效之处在于当在某个位置匹配不成功的时候能够依据之前的匹配结果从模式字符串的还有一个合适的位置開始,而不必每次都从头開始匹配。该算法由Knuth、Morris和Pratt三人设计，故取名为KMP。

KMP的改进之处

回想一下上文讲的的朴素匹配算法。每次失配的时候，都是 i++;j=0; 从画面上看，就是把模式串相对于主串向后移动一个位置。再次从模式串的首字符開始新的一轮比較。用数学的形式讲，这是 i++;j=0; 的几何意义。

失配时，记主串的下标为i，此时模式串的下标是j。

则能够肯定已有j个字符成功匹配。例如以下图：

Ti-j Ti-j+1 ...Ti-2 Ti-1 Ti

P0 P1 ...Pj-2 Pj-1 Pj 图(a)

在上图中，红色的字符是匹配上的。下标 0,1..j-1 不正好是j个吗？

KMP的做法是，充分利用已匹配的信息，失匹配时：i不变,j=next[j],当中next[j]<=j-1。即失配的时候，又一次用模式串的next[j]位置的字符和主串的i位置进行匹配。

故模式串相对主串移动的位置大小是j-next[j]>=1，在普通情况下都比朴素匹配的移动一个位置高效。这就是KMP的改进之处。

之所以敢把主串T[i]与模式串P[next[j]]直接匹配。也就是说跳过模式串的前next[j]个字符，那么以下的事实必须存在：

Ti-next[j] Ti-next[j]+1 ...Ti-2 Ti-1 Ti

P0 P1 ...Pnext[j]-2 Pnext[j]-1 Pnext[j] 图(b)

这个事实就是：模式串下标从0到next[j]-1位置的字符已经匹配成功了。

两个论断

(1)从图(a)中要明白一点：Ti-j...Ti-1和P0...Pj-1是一模一样的。所以把前者看成后者是没有问题的。

(2)从图(b)中能够得到，P0...Pnext[j]-1 是 P0...Pj-1 的前 next[j] 个连续字符子串，而 Ti-next[j]...Ti-1 也就是 Pj-next[j]...Pj-1(依据上一条结论)是 P0...Pj-1 的后next[j]个连续字符子串。而且它们是一模一样的(相应匹配)。

前缀、后缀

这就引出了前缀、后缀的概念。举一个样例就可以说明：

字符串 "abc"

它有前缀 "a" "ab" "abc"

它有后缀 "c" "bc" "abc"

看到这里，不用过多的解释，大家也可明确前后缀指的是什么呢。

next[j]的含义

结合前后缀的概念，可得出next[j]的的实际含义：next[j]就是模式串下标 0...j-1 这j个字符的最长相相应前缀和后缀的长度。

非常显然。相相应是指能够匹配得上。至于为什么是最长？，基于两点考虑：

(i)直观上看，next[j]最大。说明剩下须要进行匹配验证的字符就最少嘛。

(ii)本质上，仅仅能取最大，否则会遗漏可能的匹配。(这一点，须要细致想想！

)

须要指出。这里我们仅仅能考虑非平庸的前后缀。否则，对于平庸的无意义。

(平庸前后缀是指：空串和串本身。

其他的都是非平庸的。

)

另一点我们得明确：next数组全然由模式串本身确定。与主串无关。

求解next数组的步骤

先求出以当前字符结尾的子串的最长相相应前缀和后缀的长度。
当前字符的next值，须要參考(參考就是取的意思)上一个字符的步骤1中的求解结果。
至于第一个字符，因为没有“上一个字符”的说法。直接设置为-1。就可以。

看一个详细的样例：

模式串 "ababca"

最长前后缀长度表

模式串	a	b	a	b	c	a
最长前后缀长度	0	0	1	2	0	1

由上表得出next数组

下标	0	1	2	3	4	5
next	-1	0	0	1	2	0

直观地看就是：把“最长前后缀长度表”右移一个位置，于是最右边的一个长度被丢弃掉了，最左边空出的填上-1。这样得到的就是next数组。

next数组的递推求解

当模式串的长度非常小的时候。手动计算next数组也没什么问题。

可手动计算终究不是办法，必须机器计算。实际上next数组能够递推求解。这也是一个理解上的难点。

(i)初始 next[0]=-1;

(ii)若next[j]为k，即有 P0...Pk-1(Pk...)=Pj-k...Pj-1(Pj...)(*式)(‘=‘的意义：相应位置相匹配)。分两种情况。求解next[j+1]:

if(Pk==Pj)，则 next[j+1]=k+1=next[j]+1; 道理显而易见：若Pk与Pj相等，则最长前后缀顺势增长一个，由*式能够看出。
若Pk与Pj不相等，则更新 k=next[k];if(Pk==Pj) next[j+1]=k+1;否则。反复此过程。
(这里也是个匹配问题)

我们用手动计算得到的next数组，来进行下測试：

给定一主串 "cadabababcacadda"。模式串 "ababca"，next数组同上：next[]={-1,0,0,1,2,0}

代码

#include<iostream>
#include<iomanip>
using namespace std;
/*
依据模式串P，设置next数组的值
*/
void setNext(const char* P, int* next)
{
	int j, k, lenP;
	lenP = strlen(P);
	j = 1;
	next[0] = -1;
	while (j < lenP)
	{
		k = next[j-1];
		//P[j]!=P[k]
		while ((k >= 0) && P[j-1]!=P[k])
			k = next[k];
		if (k < 0)
			next[j] = 0;
		else
			next[j] = k + 1;
		j++;
	}
}
/*
串的模式匹配：KMP算法
(i)T是主串，其形式是字符串常量或者是以‘\0‘结尾的字符串数组，如"abc"或{‘a‘,‘b‘,‘c‘,‘\0‘}
(i)P是子串。其形式和主串一样
(i)next数组
(o)匹配成功，返回主串中第一次匹配成功的下标；否则，返回-1
*/
int KMP(const char *T, const char *P, const int *next)
{
	if (T && P)
	{
		//lenT是主串长度，lenP是子串长度
		int lenT, lenP;
		lenT = strlen(T), lenP = strlen(P);
		//主串长度小于子串，显然无法匹配
		if (lenT < lenP)
			return -1;
		int i, j, pos;
		i = j = -1;
		pos = lenT - lenP;  //i最多仅仅需变化到pos位置。想想？非常easy的
		while (i <= pos && j < lenP)
		{
			//匹配成功或第一次匹配
			if (j == -1 || T[i] == P[j])
			{
				i++;
				j++;
			}
			else//匹配失败
				j = next[j];
		}
		if (j == lenP)
			return i - lenP;  //这个返回值非常好理解
		else
			return -1;
	}
	return -1;
}
void print(int *array, int n)
{
	if (array && n > 0)
	{
		int i;
		for (i = 0; i < n; i++)
			cout << setw(4) << array[i];
		cout << endl;
	}
}
int main()
{
	cout << "***串的模式匹配：KMP算法***by David***" << endl;
	char T[] = "cadabababcacadda";
	char P[] = "ababca";
	cout << "主串" << endl;
	cout << T << endl;
	cout << "子串" << endl;
	cout << P << endl;
	int n = strlen(P);
	int *next=new int[n];
	setNext(P, next);
	cout << "打印next数组" << endl;
	print(next, n);
	cout << "使用KMP算法进行模式匹配" << endl;
	int index = KMP(T, P, next);
	if (index == -1)
		cout << "无法匹配！" << endl;
	else
		cout << "匹配成功。，匹配到的下标是 " << index << endl;
	delete[]next;
	system("pause");
	return 0;
}