字符串算法:KMP算法+BoyerMoore算法原理及C++实现

前言:

很久以前就写好了字符串搜索的几个经典算法:KMP算法、Boyer-Moore算法以及Rabin-Karp算法。但是一直没有时间写,这次我准备详细的写一下KMP算法,简略的分析下BoyerMoore算法。

原理:

KMP算法:

KMP算法是一种子字符串查找算法,它将会返回目标子字符串在文本中的下标,相比暴力检索算法KMP算法拥有更好的时间复杂度。KMP算法的基本思想 是当字符串出现不匹配的时候,我们就已经知道了一部分的文本内容(即前面以及进行过匹配的文本),我们可以利用这些信息避免检索指针多余的倒退。比如当我们在检索文本"ABABC"中是否存在ABC时,我们检索到第二个"A"时会因为不匹配而停止,若是暴力检索算法,我们会从"B"继续开始检索,但这实际上是没有必要的,因为第一次检索后我们已近直到第二个字符为"B",它并不会进行匹配,所以KMP算法会跳过第二个字符"B"直接从第三个字符"A"开始检索。如图一所示,其中颜色方框表示出现了文本的不匹配。
字符串算法:KMP算法+BoyerMoore算法原理及C++实现_第1张图片
通过上图,我们可以发现KMP算法可以根据之前的信息,避免文本指针不必要的回退,而要完成这个工作我们最好的方法是使用 确定有限状态自动机(DFA)来完成这个工作。
DFA模拟:

对于KMP算法来说,我们将根据DFA所提供的信息,来完成文本指针的回退。对于每一个文本,它有其确定的一个状态机,如对于"ABABAC"其状态机如图二所示。
而在实际代码中,我们将用二维数组dfa[R][j]来储存状态机(如图三所示),其中R为字典中字符个数,j为模式字符串的长度。

字符串算法:KMP算法+BoyerMoore算法原理及C++实现_第2张图片
当我们拥有了这个DFA以后,我们即可以开始从文本"ACABABAC"中检索"ABABAC"字符串,当我们在文本中进行检索时,我们将从文本的开头进行检索,同时构造DFA,并使其DFA进入状态0, 我们将依次遍历整个文本,并根据我们检索到的字符来变换状态机的状态,当我们进入6状态后,即完成文本的匹配;若文本检索完成后,仍未进入状态6那么则表示文本中没有相应的子字符串。(如图四所示)
字符串算法:KMP算法+BoyerMoore算法原理及C++实现_第3张图片
具体代码如下所示:
	// 通过dfa来检索子串
	int i, j;
	for (i = 0, j = 0; i < txt.length() && j < Pat.length(); i++)
		j = dfa[txt[i]][j];
	if (j == Pat.length())
		return i - Pat.length();
	else
		return txt.length();

可以发现,有了DFA过后,想要在文本中找到我们想要的字符串其实是一件非常简单的事情;但是, 整个KMP算法的难点在我看来就是如何得到DFA,这里有一个非常巧妙但是有一点绕圈的方法来构造DFA,接下来我将结合我的感受对其进行分析;
DFA构造:

DFA的构造我们将使用这样一种方法——通过已构造的DFA来构造后面的DFA,即通过前面的状态来构造后面的状态。在我看来这是非常自然的想法,难点在于我们具体该怎么做。
我们首先会 引入一个状态变量X即重启状态,用于记录当我们在某一状态匹配失败时会进入哪一个状态。(如图五所示)这么说可能不是太好理解,举个例子来说,当我们以及匹配完成"ABABA"这五个字符,但是最后一个字符为"B"与"C"匹配失败,那么对于接下来该文本"B"的匹配我们将按照"ABA"时进行匹配处理,那么这时其重启状态X为3,即当此处的字符不是"C"时,我们将按照状态3的情况来处理不匹配的字符串。而我们可以发现, 重启状态总是当前状态之前的状态,这就说明我们通过重启状态使用已构造的状态来生成新的状态。
字符串算法:KMP算法+BoyerMoore算法原理及C++实现_第4张图片
在构建重启状态时,我们可以通过上图发现,我们不需要构建初始状态(状态0)以及终止状态(状态6)的终止状态,因为这是显而易见的。那么我们该怎么构建它呢?回顾重启状态的定义, 重启状态是当匹配失败时,我们将进入哪一个状态重新匹配以确定其每个字符的对应状态;那么根据这个定义,我们可以发现后面的重启状态可以根据前面的重启状态构建。如上图中的状态5的重启状态,因为4状态时重启状态为2,那么当我们进入状态五时,可以看做当我们在状态4时进行了状态重启进入状态2,状态2中匹配由状态4进入状态5的字符"A"(见图二)使状态2进入了状态3,因此状态5的重启状态X = 3;上面这段话可能有点拗口,但是我觉得是我最好的理解了。因此我们可以发现, 所有的X可以由前一个状态的X所得出,同时状态1的X始终为0,因此我们可以通过递归或者迭代的方法构造DFA
代码如下:
	// 初始化状态机初始指向
	dfa[Pat[0]][0] = 1;
	for (int i = 1; i < Pat.length(); i++) {
		for (int c = 0; c < R; c++)
			dfa[c][i] = dfa[c][X];
		dfa[Pat[i]][i] = i + 1;

		X = dfa[Pat[i]][X]; // 更新下一状态的回溯状态
	}

到这里,KMP算法即实现完成。

Boyer-Moore算法:

Boyer-Moore算法与KMP算法相比较简单很多,因此这里只做了简要的分析。Boyer-Moore算法(以下简称BM算法)的原理同KMP有些许类似,也是通过减少模式字符串指针的回退来减少时间复杂度;不过有所不同的是,BM算法是从模式字符串的末尾开始进行检索,若出现不匹配则根据不匹配处的字符进行跳跃。
BM算法中的跳跃主要使用了一个跳跃表Right[C]来储存当字符C不匹配出现时的跳跃长度,其中具体为 字符C在模式字符串即目标子字符串中最右的位置(下标);而对于没有在模式字符串中出现的字符则储存-1。在拥有Right[ ]数组后,我们的处理将会变得很简单,我们 使用一个索引 i在文本中从左向右移动,用另一个索引 j 在模式文本中从又向左移动,判断 j处的字符是否匹配,若不匹配则根据Right[ ]数组将 i下标进行右移,同时重置 j 下标,重新开始新一轮的匹配;直到所有的模式文本匹配完成。最后返回 i 值作为子字符串在文本中的下标。

代码为:
/* BM算法:使用BM算法查找子串
 * 参数:txt:用于查找的文本
 * 返回值:int:目标字符串首字符在文本中的位置索引
 */
int SubString::BoyerMoore(string txt) {
	// 重置跳跃数组
	MakeEmpty();

	// 构造跳跃数组
	// 说明:
	//	跳跃数组中Right[char]代表字符char在Pat中最后出现的位置,若Pat中不存在则为-1
	Right = new int[R];
	for (int i = 0; i < R; i++)
		Right[i] = -1;
	for (int j = 0; j < Pat.length(); j++)
		Right[Pat[j]] = j;

	// 通过跳跃数组移动下标索引
	int Skip;
	for (int i = 0; i < txt.length(); i += Skip) {
		// 初始化移动步数
		Skip = 0;
		for(int j = Pat.length() - 1; j >= 0; j--)
			if (Pat[j] != txt[i + j]) {
				Skip = j - Right[txt[i + j]];
				if (Skip < 1)
					Skip = 1;
				break;
			}

		// 当不需要移动时则匹配成功
		if (Skip == 0)
			return i;
	}

	return txt.length();
}

/* BM算法:使用BM算法查找子串
 * 参数:pat:用于查找的模式字符串,txt:用于查找的文本
 * 返回值:int:目标字符串首字符在文本中的位置索引
 */
int SubString::BoyerMoore(string pat, string txt) {
	Pat = pat;
	return BoyerMoore(txt);
}


附录(完整代码 + 额外Rabin-Karp算法代码):

我自己在写的时候,将这些算法都封装到了一个类中,所以第一个将会是他们的声明:
#ifndef SUBSTRING_H
#define SUBSTRING_H

#include 
#include 
using namespace std;

/* SubString类:
 * 接口:
 * MakeEmpty:重置功能,重置子串查找器
 * KMP:KMP算法,使用KMP算法查找子串
 * BoyerMoose:BoyerMoose算法,使用BoyerMoose算法查找子串
 * RabinKarp:RabinKarp算法,使用RabinKarp算法查找子串
 */
class SubString
{
public:
	// 构造函数
	SubString(string pat = "");
	// 析构函数
	~SubString();

	// 接口函数
	void MakeEmpty();

	int KMP(string txt);
	int KMP(string pat, string txt);

	int BoyerMoore(string txt);
	int BoyerMoore(string pat, string txt);

	int RabinKarp(string txt);
	int RabinKarp(string Pat, string txt);

private:
	// 辅助功能函数
	int Hash(string key, int M);

	const int R = 256;

	string Pat; // 模式字符串
	int **dfa; // 储存确定优先状态自动机
	int *Right; // 储存跳跃数组
};

#endif // !SUBSTRING_H

接下来是实现文件(.cpp):
#include "SubString.h"

/* 构造函数:初始化对象
 * 参数:pat:模式字符串
 * 返回值:无
 */
SubString::SubString(string pat) {
	Pat = pat;
	dfa = NULL;
	Right = NULL;
}

/* 析构函数:对象消亡时回收储存空间
 * 参数:无
 * 返回值:无
 */
SubString::~SubString() {
	MakeEmpty();
}

/* 重置函数:重置子串查找器
 * 参数:无
 * 返回值:无
 */
void SubString::MakeEmpty() {
	// 重置确定非限制自动状态机
	for (int i = 0; i < R; i++) {
		if (dfa != NULL) {
			delete dfa[i];
			dfa[i] = NULL;
		}
	}
	delete dfa;
	dfa = NULL;

	// 重置跳跃数组
	delete Right;
	Right = NULL;
}

/* KMP算法:使用KMP算法查找子串
 * 参数:txt:用于查找的文本
 * 返回值:int:目标字符串首字符在文本中的位置索引
 */
int SubString::KMP(string txt) {
	// 重置状态机
	MakeEmpty();

	// 申请状态机
	dfa = new int*[R];
	if (dfa == NULL) {
		cout << "自动机申请失败!" << endl;
		return NULL;
	}
	for (int i = 0; i < R; i++) {
		dfa[i] = new int[Pat.length()];
		for (int j = 0; j < Pat.length(); j++)
			dfa[i][j] = 0;
	}

	// 构造状态机
	int X = 0; // 初始化回溯状态

	// 初始化状态机初始指向
	dfa[Pat[0]][0] = 1;
	for (int i = 1; i < Pat.length(); i++) {
		for (int c = 0; c < R; c++)
			dfa[c][i] = dfa[c][X];
		dfa[Pat[i]][i] = i + 1;

		X = dfa[Pat[i]][X]; // 更新下一状态的回溯状态
	}

	// 通过dfa来检索子串
	int i, j;
	for (i = 0, j = 0; i < txt.length() && j < Pat.length(); i++)
		j = dfa[txt[i]][j];
	if (j == Pat.length())
		return i - Pat.length();
	else
		return txt.length();
}

/* KMP算法:使用KMP算法查找子串
 * 参数:pat:用于查找的模式字符串,txt:用于查找的文本
 * 返回值:int:目标字符串首字符在文本中的位置索引
 */
int SubString::KMP(string pat, string txt) {
	Pat = pat;
	return KMP(txt);
}

/* BM算法:使用BM算法查找子串
 * 参数:txt:用于查找的文本
 * 返回值:int:目标字符串首字符在文本中的位置索引
 */
int SubString::BoyerMoore(string txt) {
	// 重置跳跃数组
	MakeEmpty();

	// 构造跳跃数组
	// 说明:
	//	跳跃数组中Right[char]代表字符char在Pat中最后出现的位置,若Pat中不存在则为-1
	Right = new int[R];
	for (int i = 0; i < R; i++)
		Right[i] = -1;
	for (int j = 0; j < Pat.length(); j++)
		Right[Pat[j]] = j;

	// 通过跳跃数组移动下标索引
	int Skip;
	for (int i = 0; i < txt.length(); i += Skip) {
		// 初始化移动步数
		Skip = 0;
		for(int j = Pat.length() - 1; j >= 0; j--)
			if (Pat[j] != txt[i + j]) {
				Skip = j - Right[txt[i + j]];
				if (Skip < 1)
					Skip = 1;
				break;
			}

		// 当不需要移动时则匹配成功
		if (Skip == 0)
			return i;
	}

	return txt.length();
}

/* BM算法:使用BM算法查找子串
 * 参数:pat:用于查找的模式字符串,txt:用于查找的文本
 * 返回值:int:目标字符串首字符在文本中的位置索引
 */
int SubString::BoyerMoore(string pat, string txt) {
	Pat = pat;
	return BoyerMoore(txt);
}

/* 哈希函数:计算对应字符的Hash数
 * 参数:key:想要进行计算的字符串,M:计算的长度
 * 返回值:int:目标字符串指定长度的Hash数
 */
int SubString::Hash(string key, int M) {
	int h = 0;
	for (int i = 0; i < M; i++)
		h = R * h + key[i];
	return h;
}

/* RK算法:使用RK算法查找子串
 * 参数:txt:用于查找的文本
 * 返回值:int:目标字符串首字符在文本中的位置索引
 */
int SubString::RabinKarp(string txt) {
	// 初始化查找状态
	bool Find = false;
	int d = 1;
	int PLen = Pat.length(), tLen = txt.length(); // 获取模式字符串与文本的长度
	int PatHash, txtHash;
	// 初始化模式指纹与文本指纹
	PatHash = Hash(Pat, PLen);
	txtHash = Hash(txt, PLen);

	// 获取指纹变换倍数
	for (int i = 1; i < PLen; i++)
		d *= R;

	for (int i = 0; i < tLen - PLen; i++) {
		// 比较文本指纹与模式指纹
		if (PatHash == txtHash) {
			Find = true;
			// 比较是否相同
			for (int j = 0; j < PLen; j++)
				if (txt[i + j] != Pat[j]) {
					Find = false;
					break;
				}
		}

		else {
			// 变化文本指纹
			txtHash = (txtHash - txt[i] * d) * R + txt[i + PLen];
			Find = false;
		}

		// 如果查找成功返回对应位置
		if (Find)
			return i;
	}

	return tLen;
}

/* RK算法:使用RK算法查找子串
 * 参数:pat:用于查找的模式字符串,txt:用于查找的文本
 * 返回值:int:目标字符串首字符在文本中的位置索引
 */
int SubString::RabinKarp(string pat, string txt) {
	Pat = pat;
	return RabinKarp(txt);
}
那么这次的字符串检索算法就结束了,若有什么问题欢迎大家指出~~
转载请标明出处哦~~
参考文献:《算法第四版》


你可能感兴趣的:(算法)