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

引言

字符串的模式匹配是一种常用的操作。模式匹配(pattern matching),简单讲就是在文本(text,或者说母串str)中寻找一给定的模式(pattern)。通常文本都很大,而模式则比较短小。典型的例子如文本编辑和DNA分析。在进行文本编辑时,文本通常是一段话或一篇文章,而模式则常常是一个单词。若是对某个指定单词进行替换操作,则要在整篇文章中进行匹配,效率要求肯定是很高的。

模式匹配的朴素算法

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

这如同枚举法:把母串中与模式串相同长度的子串挨个比较。则这种匹配方式显然无任何启发性或智能性。如下图:

以上步骤很容易看懂,它的代码也各种各样,下面是其中一种:

/*
朴素的模式匹配算法,匹配方向:从前往后
匹配成功,则返回匹配成功时主串的下标位置(只返回第一次匹配成功的位置)
否则,返回-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;
}

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

朴素匹配的时间复杂度是很容易分析的。若是成功匹配,最好的情况下,第一次比较就匹配上了,此时只需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数组的步骤

  1. 先求出以当前字符结尾的子串的最长相对应前缀和后缀的长度。
  2. 当前字符的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]:

  1. if(Pk==Pj),则 next[j+1]=k+1=next[j]+1;
    道理显而易见:若Pk与Pj相等,则最长前后缀顺势增长一个,由*式可以看出。
  2. 若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位置,想想?很简单的
		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;
}

运行

代码下载:KMP算法

转载请注明出处,本文地址:http://blog.csdn.net/zhangxiangdavaid/article/details/35569257

若有所帮助,顶一个哦!

专栏目录:数据结构与算法目录

时间: 07-22