串模式匹配的C++语言描述实现模板

已于 2023-02-12 13:12:51 修改
阅读量349 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 算法 c++ c语言 后端
于 2022-08-23 00:32:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62083249/article/details/126245062
版权

文章目录

前言

数据结构中串模式匹配的C++语言描述实现模板，有详细的步骤解析及使用示例。

代码仓库

暴力/简单/朴素算法

代码模板

//头文件————————————————————
#include <iostream>

//命名空间————————————————————
using namespace std;

//函数声明————————————————————
void useExample();                                      //使用示例
int index(const string &mainStr, const string &subStr); //暴力/简单/朴素算法  返回主串与子串匹配的第一个位置索引

//函数定义————————————————————
//使用示例
void useExample()
{
    const string mainStr = "abcde"; //主串
    const string subStr = "cd";     //子串

    cout << index(mainStr, subStr) << endl; //输出：2

    return;
}

//暴力/简单/朴素算法  返回主串与子串匹配的第一个位置索引
int index(const string &mainStr, const string &subStr) //参数：主串，子串
{
    int i = 0; //主串的匹配位置
    int j = 0; //子串的匹配位置
    // int k = i; //记录每轮匹配时主串和子串匹配的起始位置  用于匹配失败时主串匹配位置的定位回溯

    while (i < mainStr.size() && j < subStr.size()) //遍历主串和子串进行匹配
    {
        if (mainStr[i] == subStr[j]) //匹配成功
        {
            ++i; //继续匹配主串的下一个位置
            ++j; //继续匹配子串的下一个位置
        }
        else //匹配失败
        {
            i = i - j + 1; //主串匹配位置回溯 或：i = ++k;
            j = 0;         //子串匹配位置回溯为0
        }
    }

    if (j == subStr.size()) //遍历完子串，表明匹配成功
    {
        return i - subStr.size(); //返回主串与子串匹配的第一个位置索引  或：return k;
    }
    else //匹配失败
    {
        return -1; //返回-1
    }
}

//主函数————————————————————
int main()
{
    useExample(); //使用示例

    return 0;
}

复杂度

  • 理论时间复杂度：O(n×m)。n为主串规模，m为子串规模
  • 实际（一般情况下的）时间复杂度：：O(n+m)。n为主串规模，m为子串规模
  • 空间复杂度：O(1)。未使用辅助空间

KMP算法

核心思想

  • 作用：字符串（主串和子串）匹配；字符串（主串中的子串间）重复
  • 前缀：除最后一个字符外，字符串的首部连续子串
  • 后缀：除第一个字符外，字符串的尾部连续子串
  • 最长相等前后缀：待匹配字符前的子串中，最长且相等的前后缀子串
  • 前缀表：记录最长相等前后缀的长度
  • next数组：前缀表或值统一减一的前缀表
  • next数组的值next [ j ]：子串的第 j 个字符与主串的当前字符匹配失败，跳转到子串的第next [ j ]个字符与主串的当前字符进行匹配（可能匹配失败或匹配成功）
  • 时间复杂度：O(n+m)。n为主串规模，m为子串/next数组规模
  • 空间复杂度：O(m)。m为子串/next数组规模

代码模板

//头文件————————————————————
#include <iostream>
#include <vector>

//命名空间————————————————————
using namespace std;

//函数声明————————————————————
void useExample();                                                                  //使用示例
void getNext(const string &subStr, vector<int> &next);                              //获取next向量：值统一减一/整体右移一位的前缀表
int indexKMP(const string &mainStr, const string &subStr, const vector<int> &next); // KMP算法 返回主串与子串匹配的第一个位置索引

//函数定义————————————————————
//使用示例
void useExample()
{
    const string mainStr = "abcde"; //主串
    const string subStr = "cd";     //子串

    const int subStrSize = subStr.size(); //子串大小

    vector<int> next(subStrSize, -1); // next向量   为子串大小，初始化值-1

    getNext(subStr, next); //获取next向量

    cout << indexKMP(mainStr, subStr, next) << endl; //输出：2

    return;
}

//获取next向量：值统一减一的前缀表
void getNext(const string &subStr, vector<int> &next) //参数：子串，next向量
{
    int i = 0;  //子串中求next值位置的上一位置  主串/后缀的起始位置
    int j = -1; //子串中求next值位置的上上一位置    用于定位：因为需要依据next[j]求next[j+1]    子串/前缀的起始位置

    next[0] = -1; // next向量第一个位置的值必为-1：不存在最长相等前后缀，最长相等前后缀为0，0 - 1 = -1

    while (i < subStr.size() - 1) //遍历子串每个位置   求next值 注意：因为是上一个位置，所以需-1
    {
        // j == -1：j回退到-1，-1 + 1 = 0，最长相等前后缀的长度为0，不存在最长相等前后缀
        //++i：从主串的下一位置匹配
        //++j：j = -1 + 1 = 0，从子串的第一个位置匹配
        // next[i] = j：得next值0：
        //因为不存在最长相等前后缀；含义：若匹配失败，则从子串的第一个位置0进行匹配

        // subStr[i] == subStr[j]：匹配成功
        //++i：继续匹配主串的下一位置
        //++j：继续匹配子串的下一位置
        // next[i] = j：得next值：
        //因为匹配成功；含义：若匹配失败，则从后缀的j位置匹配（因为存在最长相等前后缀，可定位）

        //注意理解：匹配时的i是求next值的位置的上一位置，next[i] = j的++i是求next值的位置

        // else：不存在最长相等前后缀，问题转换：进一步理解为模式匹配问题，递归求next[j]得定位

        if (j == -1 || subStr[i] == subStr[j])
        {
            ++i;
            ++j;

            next[i] = j;
        }
        else
        {
            j = next[j];
        }
    }

    return;
}

// KMP算法  返回主串与子串匹配的第一个位置索引
int indexKMP(const string &mainStr, const string &subStr, const vector<int> &next) //参数：主串，子串，next向量
{
    int i = 0; //主串的匹配位置
    int j = 0; //子串的匹配位置

    const int mainStrSize = mainStr.size(); //主串大小
    const int subStrSize = subStr.size();   //子串大小

    // while (i < mainStr.size() && j < subStr.size()) //遍历主串和子串 输出错误
    while (i < mainStrSize && j < subStrSize) //遍历主串和子串
    {
        // j == -1：子串的匹配位置回溯，匹配主串的下一位置和子串的第一个位置
        // mainStr[i] == subStr[j]：匹配成功，继续匹配主串和子串的下一个位置
        // else：匹配失败，子串的匹配位置依据next向量回溯
        if (j == -1 || mainStr[i] == subStr[j])
        {
            ++i;
            ++j;
        }
        else
        {
            j = next[j];
        }
    }

    if (j == subStr.size()) //遍历完子串，表明匹配成功
    {
        return i - subStr.size(); //返回主串与子串匹配的第一个位置索引
    }
    else //匹配失败
    {
        return -1; //返回-1
    }
}

//主函数————————————————————
int main()
{
    useExample(); //使用示例

    return 0;
}

KMP改进算法

核心思想

  • 解决子串中匹配失败的字符和回溯位置的字符相同导致的冗余匹配问题
  • 时间复杂度：O(n+m)。n为主串规模，m为子串/nextval数组规模
  • 空间复杂度：O(m)。m为子串/nextval数组规模

代码模板

//头文件————————————————————
#include <iostream>
#include <vector>

//命名空间————————————————————
using namespace std;

//函数声明————————————————————
void useExample();                                                                     //使用示例
void getNextval(const string &subStr, vector<int> &nextval);                           //获取nextval向量
int indexKMP(const string &mainStr, const string &subStr, const vector<int> &nextval); // KMP算法 返回主串与子串匹配的第一个位置索引

//函数定义————————————————————
//使用示例
void useExample()
{
    const string mainStr = "abcde"; //主串
    const string subStr = "cd";   //子串

    const int subStrSize = subStr.size(); //子串大小

    vector<int> nextval(subStrSize, -1); // nextval向量   为子串大小，初始化值-1

    getNextval(subStr, nextval); //获取nextval向量

    cout << indexKMP(mainStr, subStr, nextval) << endl; //输出：2

    return;
}

//获取nextval向量
void getNextval(const string &subStr, vector<int> &nextval) //参数：子串，nextval向量
{
    int i = 0;  //子串中求nextval值位置的上一位置
    int j = -1; //子串中求nextval值位置的上上一位置   用于定位：因为需要依据nextval[j]求nextval[j+1]

    nextval[0] = -1; // nextval向量第一个位置的值必为-1

    while (i < subStr.size() - 1) //遍历子串每个位置   求nextval值 注意：因为是上一个位置，所以需-1
    {
        // j == -1：不存在最长相等前后缀，j回退到-1
        //++i：从主串的下一位置匹配
        //++j：j = -1 + 1 = 0，从子串的第一个位置匹配
        // nextval[i] = j：得nextval值
        //因为不存在最长相等前后缀，若当前位置匹配失败，则从子串的第一个位置0匹配

        // subStr[i] == subStr[j]：匹配成功
        //++i：继续匹配主串的下一位置
        //++j：继续匹配子串的下一位置

        //改进内容：
        // subStr[i] != subStr[j]：当前位置的字符和回溯位置的字符不同，当前位置的字符匹配失败时不会导致冗余匹配问题
        // nextval[i] = j：得nextval值
        //因为匹配成功，若当前位置匹配失败，则从后缀的j位置匹配（因为存在最长相等前后缀，可定位）
        // nextval[i] = nextval[j]：得nextval值
        //否则当前位置的字符和回溯位置的字符相同，当前位置的字符匹配失败时会导致冗余匹配问题
        //递归获取当前位置的字符和回溯位置的字符不同时的nextval值
        //算法保证正向获取nextval值，反向只需递归一次，当前位置的字符和回溯位置的字符必不同

        //理解：匹配时的i是求nextval值的位置的上一位置，nextval[i] = j的++i是求nextval值的位置

        // else：不存在最长相等前后缀，问题转换：进一步理解为模式匹配问题，递归求nextval[j]得定位

        if (j == -1 || subStr[i] == subStr[j])
        {
            ++i;
            ++j;

            if (subStr[i] != subStr[j])
            {
                nextval[i] = j;
            }
            else
            {
                nextval[i] = nextval[j];
            }
        }
        else
        {
            j = nextval[j];
        }
    }

    return;
}

// KMP算法  返回主串与子串匹配的第一个位置索引
int indexKMP(const string &mainStr, const string &subStr, const vector<int> &nextval) //参数：主串，子串，nextval向量
{
    int i = 0; //主串的匹配位置
    int j = 0; //子串的匹配位置

    const int mainStrSize = mainStr.size(); //主串大小
    const int subStrSize = subStr.size();   //子串大小

    // while (i < mainStr.size() && j < subStr.size()) //遍历主串和子串 输出错误
    while (i < mainStrSize && j < subStrSize) //遍历主串和子串
    {
        // j == -1：子串的匹配位置回溯，匹配主串的下一位置和子串的第一个位置
        // mainStr[i] == subStr[j]：匹配成功，继续匹配主串和子串的下一个位置
        // else：匹配失败，子串的匹配位置依据nextval向量回溯
        if (j == -1 || mainStr[i] == subStr[j])
        {
            ++i;
            ++j;
        }
        else
        {
            j = nextval[j];
        }
    }

    if (j == subStr.size()) //遍历完子串，表明匹配成功
    {
        return i - subStr.size(); //返回主串与子串匹配的第一个位置索引
    }
    else //匹配失败
    {
        return -1; //返回-1
    }
}

//主函数————————————————————
int main()
{
    useExample(); //使用示例

    return 0;
}

总结

不同参考资料中，串模式匹配的描述实现各不相同，但基本思想是一致的。作者使用规范的变量命名、提供详细的步骤解析及使用示例，应用C++语言将其整合成模板，以帮助理解记忆。

参考资料

  • 《2023版数据结构高分笔记》主编：率辉
  • 《2023年计算机组成原理考研复习指导》组编：王道论坛
  • 《大话数据结构》作者：程杰

作者的话

  • 感谢参考资料的作者/博主
  • 作者：夜悊
  • 版权所有，转载请注明出处，谢谢~
  • 如果文章对你有帮助，请点个赞或加个粉丝吧，你的支持就是作者的动力~
  • 文章在描述时有疑惑的地方，请留言，定会一一耐心讨论、解答
  • 文章在认识上有错误的地方, 敬请批评指正
  • 望读者们都能有所收获
夜悊
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
PTA-串的模式匹配（C++实现）
qq_43528395的博客
03-25 797
串的模式匹配 源代码 ///串的模式匹配 ///KMP算法 #include<iostream> #include<cstring> using namespace std; typedef int Position; const int N=1e6+1; const int M=1e5+1; Position KMP(char* String,char* Patt...
C++ 【string模拟实现】
我心如火
09-02 544
string，string模拟实现
c++算法题之的字符串模式匹配
weixin_54570755的博客
04-13 360
c++算法题之的字符串模式匹配
KMP算法——字符串匹配及其应用 时间复杂度O(M+N) 空间复杂度O(N)
Go的全部
11-06 1851
package kmp import ( "strconv" "strings" "testing" ) /* /* Knuth-Morris-Pratt算法（简称KMP），是由D.E.Knuth、J.H.Morris和V.R.Pratt共同提出的一个改进算法，消除了朴素的模式匹配算法中回溯问题，完成串的模式匹配。 算法思想： 设目标串为s，模式串为t， i、j 分别为指示s和t的指针，i、j的初值均为0。 若有 si = tj，则i和j分别增1；否则，i不变，j退回至j=next[j]的位置
串的模式匹配算法——BF算法及其复杂度
weixin_41338006的博客
12-29 9825
S串为主串，T为待匹配串，用i、j分别指示S和T中的字符位置，i、j初值均为0。 算法步骤：（1）若当前比较的字符是s【i】==T【j】，则继续向后比较，执行（i++，j++）； （2）若当前正在比较的字符不匹配呢？那么j回溯到位置0（即令j=0），i呢？回溯到主串的i-j+1处 0 1 2 3 4 5 6 7 a b a b c
数据结构（用面向对象方法与C++语言描述）课后答案
01-02
《数据结构（用面向对象方法与C++语言描述）》是由殷人昆编著的一本经典教材，专注于讲解如何利用面向对象编程的思想和C++语言来实现和理解数据结构。这本书的第二版提供了深入的数据结构理论，同时也强调了实际编程...
HALCON中VB，C++，Ｃ三种编程的范例
最新发布
04-19
6. **示例代码分析**：每个编程语言的范例可能会演示特定的图像处理任务，如识别特定物体、测量特征或执行模式匹配。通过分析这些代码，学习者可以理解如何在实际项目中应用HALCON的功能。 7. **错误处理和调试**：...
587543.rar_模式识别(视觉/语音等)_C++_
08-11
在这个项目中，C++可能被用来实现图像处理算法，如边缘检测、特征提取、模板匹配以及面部特征点的检测。 压缩包中的文件名称列表显示了项目的组成部分： 1. `FaceDetect.aps` 和 `FaceDetect.clw`：这些可能是...
基于c/c++实现的整套图像拼接程序
06-24
本项目是基于C/C++语言实现的一套完整的图像拼接程序，适用于学习和实践图像处理技术。下面我们将深入探讨这个程序可能涉及的关键知识点。 1. **图像基础**：首先，要理解图像的基本概念，包括像素、色彩模型（如...
shibie.rar_模式识别(视觉/语音等)_Visual_C++_
08-11
在这个"shibie.rar"压缩包中，包含了一个使用Visual C++编程语言实现的模式识别程序，主要目的是识别26个英文字母和10个阿拉伯数字。这个程序通过特征提取和模板匹配方法来完成字符识别，下面我们将详细探讨这些技术...
串的模式匹配
daxiangaimaoxian的博客
09-30 254
串的模式匹配
串的模式匹配算法
weixin_43549176的博客
09-02 236
串的模式匹配算法 暴力匹配Brute-Forc 算法思想： 从主串S的第一个字符起，与模式T的第一个字符比较，若相等则继续逐个比较后续字符；否则从主串的下一个字符起，重新和模式的字符比较；以此类推，直至模式T中的每个字符依次和主串S中的一个连续字符序列相匹配，则匹配成功。函数值为模式T中第一个字符相等的字符在主串中的序号，否则为0。 代码实现 int Index(SString S，SString T){ int i=1,j=1;(int k=1;//记录上次匹配开始的字符位置) while
字符串的模式匹配
changyuanchn的专栏
11-25 1167
0） 引论 这里主要想讨论一下字符串的模式匹配，主要是KMP算法。 假设我们有一个字符串S，称之为原始串；另一个字符串T，称之为模式串；字符串匹配是指找出原始串S中是否含有模式串T，如果含有，则返回S中第一个匹配项的位置； 例如Ｓ＝“ａｂｃａｂｃａｂｄｅｆ”；Ｔ＝“ａｂｃａｂｄ”；那么我们可以得到Ｓ中含有模式串Ｔ，我们返回S中第一个匹配项的位置，即３。 1） Brute-Force
数据结构——字符串模式匹配算法（BP算法&KMP算法）
ZhangJiawen的博客
10-18 1653
复习的时候觉得这一部分还是挺复杂的，就单独写了一个博客。如果有理解不对的地方，欢迎大家一起讨论。 1. 简单的模式匹配算法——BF模式匹配 串的模式匹配，是求模式串在主串中的位置。时间复杂度 O(n*m). 下面来看一下代码 int Index(SString S, SString T, int pos){ int i = pos; int j = 1; while(i <= S.Len && j <= T.Len){ if(S.ch[i] == T.ch[j])
C++常用算法及数据结构（字符串匹配算法）
Ljq0704的博客
07-04 2300
然后，在文本串中滑动窗口，比较窗口的哈希值与模式串的哈希值是否相等，以及窗口内的字符串与模式串是否相等。它的时间复杂度为O(n+m+k)，其中n为文本串长度，m为模式串平均长度，k为模式串数量。KMP算法利用模式串的特性，通过建立一个部分匹配表（Partial Match Table）来避免在模式串和文本串中的不必要的匹配和回溯。它的时间复杂度为O(n+m)，其中n为文本串长度，m为模式串长度。字符串匹配算法是指在一个文本串（较长的字符串）中查找一个模式串（较短的字符串）的出现位置或匹配情况的算法。
数据结构作业5
m0_60538401的博客
12-30 509
5
串的模式匹配算法（简单模式匹配、KMP、改进的KMP）
hi_sir_destroy的博客
08-14 1661
一、简单模式匹配 思想：从主串的第一个位置起和模式串的第一个字符进行匹配，如果相等则继续匹配，否则从主串的第二个字符开始逐一比较。以此类推，知道全部匹配完成。 如：str: ababc str1:abc 第一轮匹配：匹配失败，下次从str的第二个元素继续进行匹配 ababc abc 第二轮匹配：匹配失败，下次从str的第三个元素继续进行匹配 a...
串的模式匹配__BF KMP
Zo_ee的博客
10-16 3182
对于get_next函数来说，若T的长度为m，因只涉及简单的单循环，其时间复杂度为O(m)，而i值的不回溯，使得while循环的时间复杂度为O(n)。总结改进过的KMP算法，它是在计算出next值的同时，如果a位字符与它next值指向的位字符相等，则该a位的nextval就指向b位的nextval值， 如果不等，则该a位的nextval值就是它自己a位的的值。我们在朴素的模式匹配算法中，主串的i值是不断回溯来完成的，但是这种回溯是可以省略的，KMP模式匹配算法就是让这没必要的回溯不再发生。
多角度c++ 加速实现SSD模板匹配
06-13
以下是一些多角度的C++加速实现SSD模板匹配的方法： 1. 使用OpenMP进行并行计算。OpenMP是一种多线程计算库，可以在多核CPU上并行计算，提高计算速度。 2. 使用SIMD指令进行向量化计算。SIMD指令可以一次性处理多...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值