概念
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)
- 特点：简单，对于不长的字符串适用
- 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
-
坏字符规则示例2
-
好后缀规则示例1
-
好后缀规则示例2
-
两个规则合用示例
-
特点：是从后往前进行匹配，利用模式串本身的信息，去跳过一些肯定不匹配的情况。用散列表预存每个坏字符在模式串中对应的下标，也预存每个好后缀首字符在模式串中对应的下标。另外，好后缀规则可独立于坏字符规则使用。BM算法效率比KMP算法更好，但预处理更为复杂，所占内存空间更多。
-
时间复杂度：最坏情况O(n)，最好情况(n/m)
-
空间复杂度：O(m)
-
c++代码实现
#include<iostream>
#include<string>
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<iostream>
#include<string>
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];
}
}
}
628
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
