字符串匹配算法 学习笔记 (介绍及模板)

已于 2024-10-09 20:53:16 修改
阅读量1.2k 收藏 7
点赞数 30
文章标签： 算法 学习 笔记 c++ 数据结构
于 2024-10-09 20:43:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LPoems/article/details/142795327
版权

在字符串匹配问题中，目标是找到一个模式串（Pattern）在一个文本串（Text）中的出现位置。这类问题在实际中有着广泛的应用。本文将介绍几种经典的字符串匹配算法，并包括一些并行加速的内容。主要涉及以下几种算法：

  • 朴素算法
  • KMP算法
  • BM算法
  • Sunday算法
  • CUDA加速的朴素算法

1. 朴素字符串匹配算法（Brute Force）

原理：

最简单的字符串匹配方法是朴素算法，遍历文本串的所有可能位置，将每个位置的子串与模式串逐个字符比较。

时间复杂度：

  • 最坏情况：O(n*m)
    （其中n是文本长度，m是模式串长度）

实现：

#include <iostream>
#include <string>
#include <vector>

using namespace std;

vector<int> bruteForce(const string &text, const string &pattern) {
    vector<int> result;
    int n = text.size();
    int m = pattern.size();
    for (int i = 0; i <= n - m; i++) {
        int j;
        for (j = 0; j < m; j++) {
            if (text[i + j] != pattern[j])
                break;
        }
        if (j == m)
            result.push_back(i);
    }
    return result;
}

int main() {
    string text = "ABABABABCABABABCABABABC";
    string pattern = "ABABABC";
    vector<int> result = bruteForce(text, pattern);
    for(auto & i:result)
        cout << "Pattern found at index " << i << endl;
    return 0;
}

2. KMP算法（Knuth-Morris-Pratt）

原理：

KMP算法通过构建next数组，避免在匹配失败后对已经比较过的字符重新比较，从而提升效率。

在求解next数组的过程中，遍历模式串，并使用双指针法维护两个变量：当前字符位置i和已经匹配的最长前缀的长度len。具体步骤如下：

  1. 初始化一个长度为模式串长度的数组next，并将next[0]设为0，因为第一个字符没有前缀和后缀可比。
  2. 使用变量i从第二个字符开始遍历模式串。如果当前字符pattern[i]与pattern[len]相等，表示前缀和后缀相同，此时len++，并将next[i]设置为len，然后继续处理下一个字符（i++）。
  3. 如果当前字符不匹配，并且len不为0，则将next回退为next[len-1]，相当于找到前一位置的最长前缀后缀长度，继续比较。
  4. 如果len为0，说明当前字符无法匹配任何前缀，则将next[i]置为0，并移动到下一个字符。

通过这种方式，next数组能高效记录模式串中每个位置的最长前缀后缀匹配信息，确保KMP算法在主串匹配时能快速跳过无效的匹配尝试。

时间复杂度：

  • 最坏情况：O(n + m)

实现：

#include <iostream>
#include <vector>

using namespace std;

vector<int> computeLPSArray(const string &pattern) {
    int m = pattern.size();
    vector<int> next(m, 0);
    int len = 0;
    int i = 1;

    while (i < m) {
        if (pattern[i] == pattern[len]) {
            len++;
            next[i] = len;
            i++;
        } else {
            if (len != 0) {
                next = next[len - 1];
            } else {
                next[i] = 0;
                i++;
            }
        }
    }
    return next;
}

void KMPSearch(const string &text, const string &pattern) {
    int n = text.size();
    int m = pattern.size();
    vector<int> lps = computeLPSArray(pattern);
    int i = 0, j = 0;

    while (i < n) {
        if (pattern[j] == text[i]) {
            i++;
            j++;
        }
        if (j == m) {
            cout << "Pattern found at index " << i - j << endl;
            j = lps[j - 1];
        } else if (i < n && pattern[j] != text[i]) {
            if (j != 0) {
                j = lps[j - 1];
            } else {
                i++;
            }
        }
    }
}

int main() {
    string text = "ABABABABCABABABCABABABC";
    string pattern = "ABABABC";
    KMPSearch(text, pattern);
    return 0;
}

3. BM算法（Boyer-Moore）

原理：

BM算法通过预处理模式串，使用坏字符规则和好后缀规则来跳过不必要的字符比较，使得匹配效率极高。

坏字符规则的思想是，当模式中的字符与文本中的字符不匹配时，我们可以直接跳过一些无关的字符，而不是一个字符一个字符地滑动模式。

  1. 当模式中的字符与文本中的字符不匹配时，记录这个“坏字符”。
  2. 在模式中查找该“坏字符”最近的出现位置。
  3. 根据“坏字符”在模式中的位置，决定模式向右滑动多少步，以避免不必要的比较。

好后缀规则通过匹配后缀的部分，来进一步加快模式滑动速度。

  1. 当发生不匹配时，先看看模式中是否有与已匹配部分（即“好后缀”）相匹配的部分。
  2. 如果有，模式可以直接跳到这个匹配部分的位置。
  3. 如果没有，那么根据某些情况决定移动模式到某个合理的位置。

时间复杂度：

  • 平均情况：O(n/m)
  • 最坏情况：O(n * m)

实现：

#include <iostream>
#include <vector>

using namespace std;

void badCharHeuristic(const string &pattern, int size, int badChar[256]) {
    for (int i = 0; i < 256; i++)
        badChar[i] = -1;

    for (int i = 0; i < size; i++)
        badChar[(int)pattern[i]] = i;
}

void BMSearch(const string &text, const string &pattern) {
    int n = text.size();
    int m = pattern.size();

    int badChar[256];
    badCharHeuristic(pattern, m, badChar);

    int s = 0;
    while (s <= (n - m)) {
        int j = m - 1;

        while (j >= 0 && pattern[j] == text[s + j])
            j--;

        if (j < 0) {
            cout << "Pattern found at index " << s << endl;
            s += (s + m < n) ? m - badChar[text[s + m]] : 1;
        } else {
            s += max(1, j - badChar[text[s + j]]);
        }
    }
}

int main() {
    string text = "ABABABABCABABABCABABABC";
    string pattern = "ABABABC";
    BMSearch(text, pattern);
    return 0;
}

4. Sunday算法

原理：

Sunday算法是BM算法的一种变体，它预处理的是模式串紧随文本中当前窗口的字符，以此决定滑动步长。
一旦发现某一位置的字符不匹配，Sunday算法并不会逐个字符地往后滑动模式串，而是根据主串当前不匹配位置之后的一个字符来决定滑动的步长（这就是与BM算法不同的地方）
如果模式串后一个字符在模式串中出现，则将模式串移动到该字符在模式串中的最后一次出现位置的对齐处。
如果模式串后一个字符在模式串中没有出现，则直接将模式串向后滑动整个模式串长度+1的位置。

时间复杂度：

  • 最坏情况：O(n * m)
  • 平均情况：O(n)

实现：

#include <iostream>
#include <string>
#include <vector>

using namespace std;

void SundaySearch(const string &text, const string &pattern) {
    int n = text.size();
    int m = pattern.size();
    vector<int> shift(256, m + 1);

    for (int i = 0; i < m; i++) {
        shift[pattern[i]] = m - i;
    }

    int i = 0;
    while (i <= n - m) {
        int j = 0;
        while (j < m && pattern[j] == text[i + j]) {
            j++;
        }
        if (j == m) {
            cout << "Pattern found at index " << i << endl;
        }
        i += shift[text[i + m]];
    }
}

int main() {
    string text = "ABABABABCABABABCABABABC";
    string pattern = "ABABABC";
    SundaySearch(text, pattern);
    return 0;
}

5. CUDA加速字符串匹配

原理：

CUDA可以利用GPU的并行计算能力对大规模数据进行加速处理。在字符串匹配中，可以将每个字符的比较任务分发到不同的线程，从而并行完成匹配操作。

CUDA实现朴素算法：

#include <iostream>
#include <cuda_runtime.h>

using namespace std;

__global__ void bruteForceCUDA(char* d_text, char* d_pattern, int n, int m, int* d_result) {
    int idx = blockIdx.x * blockDim.x + threadIdx.x;
    if (idx <= n - m) {
        bool match = true;
        for (int j = 0; j < m; j++) {
            if (d_text[idx + j] != d_pattern[j]) {
                match = false;
                break;
            }
        }
        if (match) {
            d_result[idx] = 1;
        }
    }
}

int main() {
    string text = "ABABABABCABABABCABABABC";
    string pattern = "ABABABC";
    int n = text.size();
    int m = pattern.size();

    char* d_text;
    char* d_pattern;
    int* d_result;
    int* result = new int[n - m + 1]();

    cudaMalloc(&d_text, n * sizeof(char));
    cudaMalloc(&d_pattern, m * sizeof(char));
    cudaMalloc(&d_result, (n - m + 1) * sizeof(int));

    cudaMemcpy(d_text, text.c_str(), n * sizeof(char), cudaMemcpyHostToDevice);
    cudaMemcpy(d_pattern, pattern.c_str(), m * sizeof(char), cudaMemcpyHostToDevice);

    bruteForceCUDA<<<(n - m + 1) / 256 + 1, 256>>>(d_text, d_pattern, n, m, d_result);

    cudaMemcpy(result, d_result, (n - m + 1) * sizeof(int), cudaMemcpyDeviceToHost);

    for (int i = 0; i <= n - m; i++) {
        if (result[i] == 1) {
            cout << "Pattern found at index " << i << endl;
        }
    }

    cudaFree(d_text);
    cudaFree(d_pattern);
    cudaFree(d_result);
    delete[] result;

    return 0;
}

简单的实验对比

数据：大肠杆菌基因组序列的一个片段
Brute Force: 10 microseconds, Matches: 921
KMP: 15 microseconds, Matches: 921
BM: 4 microseconds, Matches: 921
Sunday: 4 microseconds, Matches: 921

总结：

不同的字符串匹配算法在不同场景下各有优势：

  • 朴素算法简单易懂，适合小规模数据。
  • KMP算法适合需要频繁回退匹配的场景。
  • BM和Sunday算法在大规模文本匹配中效率较高。
  • CUDA加速算法则适用于大规模并行计算环境，在硬件支持的情况下能够极大提升性能。
LPoems
关注
Acwing算法基础课学习笔记
togph的博客
04-16 1880
Acwing 算法基础学习笔记
字符串匹配算法学习笔记
包络面的博客
04-03 456
字符串匹配算法，包括朴素字符串匹配算法、Rabin-Karp算法、利用有限自动机进行字符串匹配，和Knuth-Morris-Pratt算法。
学习笔记：KMP字符串匹配算法
pigonered的博客
11-17 244
前言 其实很早就学了，不过还是感觉很迷。但做到了NOIP2020的T2，只有学一下了。 原理 KMP是由3名数学家搞出来的算法，KMP也就是这3位的首字母。 模板传送门luoguP3375 首先看题目要求给定2个字符串，要求其中的一个字符串在另一个字符串里出现的次数。 容易想到暴力： 直接枚举2个串，如果不同，就将去匹配的串从头开始重新从匹配失败的位置继续找。 最坏的时间复杂度是：O(nm) 这个暴力算法叫做BF算法。 我们发现这个算法最主要的问题是每次从头开始重新匹配，其实可以从其中的某个地方开始找，
学习笔记——KMP字符串匹配算法
蒟蒻的博客
05-04 582
简介 KMP算法是一种字符串匹配算法，它利用了模式串（被匹配串）自身的相关信息来减少匹配次数。本文假设文本串（待匹配串）为T，模式串（被匹配串）为P。而T，P的长度分别为TLen，PLen。记Ti为T的前i个字符构成的子串，T-i为T后i个字符构成的子串，P同理。 求辅助数组 在实现这个算法前，我们需要先求一个特殊的数组，暂且记为Pre[PLen+1]。这个数组的含义为Pre[i]=max(j),...
算法学习笔记（C++）——字符串处理
胖虎的博客
05-01 305
算法学习笔记（C++）——字符串string处理 string基础知识 为使用string标准模板，需要添加头文件# include 关于其初始化，可直接使用字符串给变量赋值 string str = "hello world"; // or string str = str + " !!!"; 关于其长度，可以使用size()和length()两种方法 关于其访问，有两种方式：下标访问和迭代器访问 （1）下标访问： string str = "hello world"; for (int i=
C++学习笔记之算法模板
sincerelover的博客
08-18 901
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档。
这可能是全网最好的字符串匹配算法讲解
2401_83916241的博客
04-08 1134
面试是跳槽涨薪最直接有效的方式，马上金九银十来了，各位做好面试造飞机，工作拧螺丝的准备了吗？掌握了这些知识点，面试时在候选人中又可以夺目不少，暴击9999点。机会都是留给有准备的人，只有充足的准备，才可能让自己可以在候选人中脱颖而出。《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》点击传送门即可获取！om: 33%;" />面试是跳槽涨薪最直接有效的方式，马上金九银十来了，各位做好面试造飞机，工作拧螺丝的准备了吗？
数据结构与算法之美笔记——基础篇（下）：图、字符串匹配算法（BF 算法和 RK 算法、BM 算法和 KMP 算法 、Trie 树和 AC 自动机）
页页的博客
11-28 753
数据结构与算法之美笔记——基础篇（下）：图、字符串匹配算法（BF 算法和 RK 算法、BM 算法和 KMP 算法 、Trie 树和 AC 自动机）
【算法竞赛学习笔记】后缀自动机SAM-超经典的字符串问题详解
SC_Linno的博客
11-20 1710
title : 后缀自动机 date : 2021-11-11 tags : ACM,字符串 author : Linno 前置知识 KMP，Trie，AC自动机等字符串基础 DFA（有限状态自动机） 后缀自动机(Suffix automaton ,SAM) 定义 字符串s的SAM是一个接受s的所有后缀的最小DFA（确定性有限自动机）。直观上SAM是给定字符串的所有字串的压缩形式。而构造的时间复杂度和空间复杂度仅为O(n)O(n)O(n)。一个SAM最多有2n-1个节点和3n-4条转移边。 符号定义 .
算法学习笔记.pdf
06-22
KMP算法是一种改进的字符串匹配算法，通过预处理模式串（pattern）来实现在文本串（text）中高效匹配。它通过一个next数组来避免重复比较已经匹配的字符。 十四、贪心算法 贪心算法是一种在每一步选择中都采取当前...
python学习笔记附带源码及实战
03-10
"10-正则表达式"章节可能包含了如何创建和使用正则表达式来匹配字符串、查找模式、替换文本等内容。这在处理数据清洗、文本分析和网页抓取等场景中非常实用。 【电子词典】 "12-电子词典"项目可能是构建一个简单的...
Python学习笔记 - 探索内置字符串函数
Mr数据杨
07-08 220
通过本教程的学习，读者已经掌握了Python中常见的字符串操作方法，包括字符串索引、切片、步幅、变量插入和修改等。每一种操作都对应不同的应用场景，从解析和操作文本，到生成动态内容，再到处理用户输入，这些技巧在编程实践中至关重要。掌握这些字符串操作，不仅可以提高代码的灵活性和效率，还能够帮助开发者在面对复杂的文本处理任务时游刃有余。希望通过这份教程，读者能够更深入地理解和应用Python中的字符串操作，为今后的编程工作打下坚实的基础。
点云配准之点到点，点到面，点到线ICP，NDT算法介绍
qq_54375651的博客
11-10 1240
点云配准在人工智能，自动驾驶，SLAM等任务中具有十分关键的作用，本文将介绍点云配准的点到点，点到线，点到面ICP和NDT算法
二分查找习题篇(上)
zoelinkailuo的博客
11-07 982
给定⼀个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。这里，我们把数组的元素分为两部分——小于等于target的部分[left,Bright] and 大于target的部分[Bright+1,right]。这里，我们把数组的元素分为两部分——平方后小于等于x的部分[1,mid] and 平方后大于x的部分[mid-1, x]和一个目标值，在数组中找到目标值，并返回其索引;
数组类算法【leetcode】
随便写写
11-07 362
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。二分查找 用于有序数组中，没有重复的数组。首先需要定义一个头（left）和尾(right)，最后通过mid和target对比不断修改头和尾指向的位置。【需要注意区间问题，根据区间的开和闭决定边界条件】推荐练习 leetcode35.
GJ Round (2024.10) Round 8~21
lunjiahao的博客
11-06 885
前言： 点此 返回 GJ Round 目录 Round 8 (10.5) A 给定 nnn 个区间，每个区间 [li,ri][l_i,r_i][li​,ri​]，最大化选取区间对数，使得每对区间 [li,ri],[lj,rj][l_i,r_i],[l_j,r_j][li​,ri​],[lj​,rj​] 满足 [li,ri]∩[lj,rj]=∅[l_i,r_i] \cap [l_j,r_j] =\varnothing[li​,ri​]∩[lj​,rj​]=∅ 先按 lil_ili​ 从小到大排序，再按
【刷题】优选算法
林宇恒的博客
11-06 504
如图，我们先算出最左边(1)和最右边(7)围起来的容量，然后，7不动，1继续和7的左边3，8，4...遍历算出容量，你会发现底是不断缩短的，同时高一直都是1，因为高只有两种情况，比它小或和它相等，所以1和7左边的值算出来的容量都是比1和7的容量小的，因为底在不断变小同时高可能不变也可能变小。根据两个实例和鸽巢原理可以发现不断的平方和最终都会形成环，所以我们可以联想到用快慢指针，慢指针走一步，快指针走两步，最终会在环相遇，判断相遇时是否为1。第一个实例是快乐数，因为会变为1且不断是1的循环。
多智能体深度确定性策略梯度(MADDPG)算法复现教程
最新发布
weixin_47776213的博客
11-11 651
MADDPG算法复现
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值