BF算法+RK算法+BM算法+KMP算法笔记+实现

概念

1.什么叫子串,主串,模式串?
  • 如果在字符串a中查找字符串b,那么字符串a就是主串,字符串b就是模式串
  • 串中任意个连续字符组成的子序列称为该串的子串,最长的子串就等于该字符串
2.什么叫字符串匹配?
  • 给定主串S,判断模式串s是否是S的子串,如果是则返回模式串s的第一个字符在主串S中的位置,否则返回-1
3.什么叫单模式串匹配,多模式串匹配?
  • 单模式串匹配:在一个主串中查找一个模式串
  • 多模式串匹配:在一个主串中查找多个模式串
4.什么叫字符串的前缀、后缀、部分匹配值?
  • 'ababa’的前缀有{a,ab,aba,abab},后缀有{a,ba,aba,baba},两个集合的交集为{a,aba},其中aba为最长的相等前后缀,长度为3,所以字符串’ababa’的部分匹配值就为3
  • 注意:'a’的前缀和后缀都为空集

暴力匹配算法

  • BF(BruteForce)算法:暴力匹配算法(也称朴素模式匹配算法)
  • 算法原理:检查主串中起始位置为1、2…n-m的子串是否跟模式串匹配
  • 时间复杂度:O(nm),最坏情况下要比对n-m+1次,每次需比对m个字符(注:笔记里所有时间复杂度中的n表示主串长度,m表示模式串长度)
  • 空间复杂度:O(1)
  • 特点:简单,对于不长的字符串适用
    BF算法+RK算法+BM算法+KMP算法笔记+实现_第1张图片
  • c++代码实现
//字符串暴力匹配算法
int BF_Match(string masterStr, string patternStr) 
{
	//声明三个循环变量
	int i, j, k;
	//注意最坏情况下要比对n-m+1次
	for (i = 0; i < masterStr.size() - patternStr.size() + 1; i++)
	{
		//i的值代表已经比较了多少次,也同时代表主串中起始比对的字符的下标
		//j的值代表主串中起始比对的字符的下标
		//k的值代表模式串中起始比对的字符下标,模式串总是从0开始比对
		for (j = i, k = 0; k < patternStr.size(); j++, k++)
		{
			if (masterStr[j] != patternStr[k]) {
				break;//出现不匹配的字符立马终止,进入下轮匹配
			}
		}
		if (k == patternStr.size()) {
			return i;//匹配成功
		}
	}
	return -1;
}

RK算法

  • Rabin-Karp算法:由两位发明者Rabin和Karp的名字命名
  • 算法原理:是借助哈希算法对BF算法的改造。对主串的n-m+1个与模式串等长的子串求哈希值(哈希函数依情况而定),然后拿每个子串的哈希值与模式串的哈希值比对,若相等则匹配
  • 整个RK算法包括两部分:①求所有子串哈希值部分 ②子串哈希值与模式串哈希值比较部分
  • 时间复杂度:O(n),第①部分只需扫描一遍主串就能算出所有子串哈希值(n-m+1个),因此为O(n),第②部分每次哈希值比较的时间复杂度为O(1),需比较n-m+1次
  • 空间复杂度:O(1),可以不用数组来预先存储每个子串的哈希值,算出一个值就与模式串的值比较一次,若匹配就不必算后面子串的哈希值了,所以没用额外空间
  • 特点:相对BF算法而言,减少了比较的时间,但增加了计算哈希值的时间,所以哈希算法的设计很重要
  • 实现(略)

BM算法

  • Boyer-Moore算法

  • BM算法原理包含两部分:坏字符规则、好后缀规则

  • 坏字符规则示例1
    BF算法+RK算法+BM算法+KMP算法笔记+实现_第2张图片

  • 坏字符规则示例2
    BF算法+RK算法+BM算法+KMP算法笔记+实现_第3张图片

  • 好后缀规则示例1
    BF算法+RK算法+BM算法+KMP算法笔记+实现_第4张图片

  • 好后缀规则示例2
    BF算法+RK算法+BM算法+KMP算法笔记+实现_第5张图片

  • 两个规则合用示例
    BF算法+RK算法+BM算法+KMP算法笔记+实现_第6张图片

  • 特点:是从后往前进行匹配,利用模式串本身的信息,去跳过一些肯定不匹配的情况。用散列表预存每个坏字符在模式串中对应的下标,也预存每个好后缀首字符在模式串中对应的下标。另外,好后缀规则可独立于坏字符规则使用。BM算法效率比KMP算法更好,但预处理更为复杂,所占内存空间更多。
    BF算法+RK算法+BM算法+KMP算法笔记+实现_第7张图片

  • 时间复杂度:最坏情况O(n),最好情况(n/m)

  • 空间复杂度:O(m)

  • c++代码实现

#include
#include
using namespace std;

int main() {
	string masterStr, patternStr;
	cout << "请输入主串:";
	getline(cin, masterStr);//可输入带空格的字符串
	cout << "请输入模式串:";
	getline(cin, patternStr);
	cout << BM_Match(masterStr, patternStr);
}

int BM_Match(string masterStr, string patternStr) 
{
	int indexOfBadChar[256]; //记录模式串中每个字符最后出现的下标位置
	generateHashTable(patternStr, indexOfBadChar);//构建坏字符哈希表
	int* suffix = new int[patternStr.size()];//存储在模式串中跟好后缀相匹配的子串的起始下标值
	bool* prefix = new bool[patternStr.size()];//记录模式串的后缀子串是否匹配模式串的前缀子串
	generateSuffixAndPrefix(patternStr, suffix, prefix);
	int firstMatchIndex = 0;//表示主串与模式串对齐的第一个字符,即:主串从第几个字符开始与模式串进行匹配
	while (firstMatchIndex <= masterStr.size() - patternStr.size()) 
	{
		int lastMatchIndex;//循环变量,也是模式串从后往前匹配的字符的下标
		for (lastMatchIndex = patternStr.size()-1; lastMatchIndex >= 0; lastMatchIndex--)//模式串从后往前匹配
		{
			//firstMatchIndex + lastMatchIndex是与模式串从后往前的匹配中,主串里对应字符的下标
			if (masterStr[firstMatchIndex + lastMatchIndex] != patternStr[lastMatchIndex]) break;//此时,坏字符对应的模式串中字符的下标是lastMatchIndex
		}

		//说明匹配成功,返回主串与模式串第一个匹配的字符的位置
		if (lastMatchIndex < 0) return firstMatchIndex;
		
		/*否则,将模式串往后滑动(lastMatchIndex - indexOfBadChar)位
		其中,lastMatchIndex是坏字符对应的模式串中字符的下标,indexOfBadChar是坏字符在模式串中的位置下标
		indexOfBadChar预先存在了hash表中,所以可以直接取出来*/
		int stepsByBadCharRule = lastMatchIndex - indexOfBadChar[(int)masterStr[firstMatchIndex + lastMatchIndex]];//等同于模式串往后滑动的位数
		int stepsByGoodSuffixRule = 0;
		if (lastMatchIndex < patternStr.size() - 1) //如果遇到坏字符时存在好后缀
		{
			stepsByGoodSuffixRule = moveByGoodSuffixRule(lastMatchIndex, patternStr.size(), suffix, prefix);
		}
		int steps = max(stepsByBadCharRule, stepsByGoodSuffixRule);
		firstMatchIndex = firstMatchIndex + steps;
	}
	return -1;//匹配失败
}

int moveByGoodSuffixRule(int lastMatchIndex, int sizeOfPattern, int suffix[], bool prefix[])
{
	//lastMatchIndex表示坏字符对应的模式串中字符的下标
	int k = sizeOfPattern - lastMatchIndex - 1; //k代表好后缀长度
	if (suffix[k] != -1) return lastMatchIndex - suffix[k] + 1;
	
	//lastMatchIndex是坏字符,lastMatchIndex+1是好后缀起始,lastMatchIndex+2是好后缀的后缀子串起始
	for (int suffixSub = lastMatchIndex + 2; suffixSub < sizeOfPattern; suffixSub++)
	{
		if (prefix[sizeOfPattern - suffixSub] == true) return suffixSub;
	}
	return sizeOfPattern;
}

/*
假设字符串的字符集不大,每个字符长度是1字节,用大小为256的数组来记录每个字符在模式串中出现的位置
数组下标为对应字符的ASCII码值,数组中存储这个字符在模式串中出现的位置
该哈希表记录坏字符在模式串中的位置下标,若模式串中不存在该坏字符则值为-1
*/
void generateHashTable(string patternStr, int indexOfBadChar[]) 
{
	//初始化哈希表,数组大小为256,因为ASCII码是一个字节
	for (int i = 0; i < 256; i++)
	{
		indexOfBadChar[i] = -1;
	}
	//计算模式串中每个字符的下标位置,存到哈希表中,若模式串中有相同字符,则记录位置靠后字符的下标
	for (int i = 0; i < patternStr.size(); i++)
	{
		int ascii = (int)patternStr[i];
		indexOfBadChar[ascii] = i;
	}
}

/*
suffix数组的下标表示后缀子串的长度,存储在模式串中跟好后缀相匹配的子串的起始下标值
prefix数组来记录模式串的后缀子串是否匹配模式串的前缀子串
好后缀本身就是模式串的后缀子串
好后缀规则的两个核心内容:
1.在模式串中,查找与好后缀匹配的子串
2.在好后缀字符串的后缀子串中,查找最长的能和模式串前缀子串匹配的后缀子串
*/
void generateSuffixAndPrefix(string patternStr, int suffix[], bool prefix[]) 
{
	//初始化两个数组
	//suffix[i] = -1表示模式串中不存在跟长度为i的好后缀匹配的子串
	//prefix[i] = -1表示模式串中没有跟长度为i的后缀子串匹配前缀子串
	for (int i = 0; i < patternStr.size(); i++)
	{
		suffix[i] = -1;
		prefix[i] = false;
	}
	
	for (int subStr = 0; subStr < patternStr.size(); subStr++)
	{
		//startIndex是相同后缀子串的起始下标
		int startIndex = subStr;
		//相同后缀子串的长度
		int k = 0;
		//拿下标从0到subStr的子串(subStr从0到模式串长度-2)与整个模式串求相同后缀子串
		while (startIndex >= 0 && patternStr[startIndex] == patternStr[patternStr.size() - 1 - k])
		{
			//记录suffix[k] = startIndex
			suffix[k] = startIndex;
			--startIndex;
			++k;
		}
		//如果startIndex等于0,则说明,相同后缀子串也是模式串的前缀子串,则记录prefix[k] = true
		if (startIndex == -1) prefix[k] = true;
	}
}

//算法学习中,相较于视频讲解与演示,文字显得如此无力,所以学算法最好看视频学,文字只适于总结补充,验证和梳理思路

KMP算法

  • KMP 算法是根据三位作者(D.E.Knuth,J.H.Morris,V.R.Pratt)的名字来命名,全称是 Knuth Morris Pratt 算法
  • 算法原理:假设模式串长度为n,依次求模式串的每个前缀子串部分匹配值(共n-1个),放到next数组中(从next[1]开始放,next[0]放-1),next数组长度等于模式串长度。然后利用next数组,每当匹配失败时,可以将模式串多移动几位,且不用像暴力匹配算法那样回退指向主串的指针(主串不回溯)
  • 时间复杂度:O(n+m),求next数组O(m) + KMP匹配过程O(n)
  • 空间复杂度:O(m)
  • 特点:和BM算法一样,依然是利用模式串本身自带的信息来提高匹配效率,不一样的是KMP是从前往后匹配,利用部分匹配成功的前缀来减少一些不必要的比较,其主要优点是主串不回溯
  • C++代码实现
#include
#include
using namespace std;

int KMP_Match(string masterStr, string patternStr);
void get_Next(string patternStr, int next[]);
void optimize_Next(string patternStr, int next[], int nextPro[]);
void get_nextPro(string patternStr, int nextPro[]);
int main() {
	string masterStr, patternStr;
	cout << "请输入主串:";
	getline(cin, masterStr);
	cout << "请输入模式串:";
	getline(cin, patternStr);
	cout << KMP_Match(masterStr, patternStr);
	return 0;
}

int KMP_Match(string masterStr, string patternStr) {
	int* next = new int[patternStr.size()];
	int* nextPro = new int[patternStr.size()];
	get_Next(patternStr, next);
	optimize_Next(patternStr,next, nextPro);
	//get_nextPro(patternStr, nextPro);
	int m_index = 0;
	int p_index = 0;
	int m_size = masterStr.size();
	int p_size = patternStr.size();
	while (m_index < m_size && p_index < p_size) {
		//p_index = -1时说明上一次匹配中,主串的第m_index个位置与模式串的第一个字符不等
		if (p_index == -1 || masterStr[m_index] == patternStr[p_index]) {
			m_index++;
			p_index++;
		}else{
			//当模式串第p_index个字符与主串失配时,跳到nextPro[p_index]的位置重新与主串当前位置进行比较
			p_index = nextPro[p_index];
		}
	}
	if (p_index == patternStr.size()) {
		return m_index - patternStr.size();
	}else {
		return -1;
	}
}


void get_Next(string patternStr, int next[]) {
	//next[i]表示下标为i之前的字符串(不包括i)所具有的最长可匹配前缀的字符个数,next[0]= -1无意义,为了方便编程实现
	next[0] = -1;
	next[1] = 0;
	int i = 0, j = 1;
	while (j < patternStr.size() - 1) {
		//
		if ( i==-1 || patternStr[i] == patternStr[j]){
			//i是最长可匹配前缀的结尾下标,所以++i后就是最长可匹配前缀的字符个数
			//若因patternStr[i] == patternStr[j]进入,则next[j+1] = next[j] + 1
			next[++j] = ++i;
		}else {
			/*
			i = next[i]的含义:找次长可匹配前缀。
			怎么找?—>次长可匹配前缀就是最长可匹配前缀的最长可匹配前缀
			如果一直找不到,就递归到i==-1,i++后即最长可匹配前缀字符个数:0
			*/
			i = next[i];
		}
	}
}

//求出next数组后,优化成nextPro数组
void optimize_Next(string patternStr, int next[],int nextPro[]) {
	nextPro[0] = -1;
	for (int i = 1; i < patternStr.size(); i++)
	{
		if (patternStr[next[i]] == patternStr[i]) {
			nextPro[i] = nextPro[next[i]];
		}
		else {
			nextPro[i] = next[i];
		}
	}
}

//直接求优化后nextPro数组
void get_nextPro(string patternStr, int nextPro[]) {
	nextPro[0] = -1;
	int i = -1, j = 0;
	while (j < patternStr.size() - 1) {
		if (i == -1 || patternStr[i] == patternStr[j]) {
			++i;
			++j;
			if (patternStr[i] == patternStr[j]) {
				nextPro[j] = nextPro[i];
			}
			else {
				nextPro[j] = i;
			}
		}
		else {
			i = nextPro[i];
		}
	}
}

你可能感兴趣的:(数据结构与算法,算法,数据结构,c++)