【算法与数据结构】字符串匹配算法

已于 2023-07-05 10:05:19 修改
阅读量688 收藏 3
点赞数 1
分类专栏： 算法 文章标签： 算法
于 2023-07-04 15:19:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45765437/article/details/131535805
版权

文章目录

所有的LeetCode题解索引，可以看这篇文章——【算法和数据结构】LeetCode题解。

一、暴力穷解法

  思路分析：首先判断字符串是否合法，然后利用for循环，取出子字符串利用compare函数进行比较。
  程序如下：

class Solution {
public:
	// 复杂度n * m
	int strStr(string haystack, string needle) {
		if (haystack.size() < needle.size()) return -1;	
		if (!needle.size()) return 0; // needle为空返回0
		for (int i = 0; i < haystack.size(); ++i) {
			string substr = haystack.substr(i, needle.size());
			if (!needle.compare(substr)) return i;
		}
		return -1;
	}
};

复杂度分析：

  • 时间复杂度： O ( n ∗ m ) O(n * m) O(n∗m)，假设haystack的长度为n，needle的长度为m，for循环的复杂度为n，当中调用了compare函数，它是逐字符比较的，复杂度为m，因此总复杂度为 O ( n ∗ m ) O(n * m) O(n∗m)。
  • 空间复杂度： O ( 1 ) O(1) O(1)。

二、KMP算法

  KMP成功实现了字符串匹配算法从乘法复杂度到线性复杂度的跨越。KMP算法是由这三位学者发明的：Knuth，Morris和Pratt，所以得名KMP算法。KMP算法的主要思想是：当出现字符串不匹配时，可以知道一部分之前已经匹配的文本内容，可以利用这些信息避免从头再去做匹配。在KMP算法当中，利用next数组记录前缀表（prefix table）。前缀表用来回退，它记录了模式串与文本串不匹配的时候，模式串应该从哪里开始重新匹配。文本串是指要搜寻的字符串，模式串是目标字符串。例如，要在aabaaf当中找aaf，那么aaf就是模式串，aabaaf就是文本串。
  在next数组当中我们保存了模式串前缀的最长公共前后缀长度，以下简称为前缀表。字符串的前缀是指不包含最后一个字符的所有以第一个字符开头的连续子串；后缀是指不包含第一个字符的所有以最后一个字符结尾的连续子串，所谓最长公共前后缀，笔者理解为既在前缀中，又在后缀中，且长度最大的字符串。例如对于字符串 aabaa，其前缀有 a, aa, aab, aaba，后缀有a, aa, baa, abaa。最长公共前后缀就是 aa。
  那么为什么前缀表能告诉我们上次匹配的位置呢？考虑一个文本串aabaabaafa和模式串aabaaf。求出前缀表如下：

在这里插入图片描述

  假设我们在f位置，文本字符和模式字符不匹配（aabaa与模式串全部匹配），那么我们就得找f字符的前一个前缀字符串，也就是aabaa，前缀表next当中保存着所有前缀最长公共前后缀长度，aabaa的最长公共前后缀长度为2。也就是说，后缀aa匹配，那么前缀aa也必然和模式串匹配，因此前缀aa不需要再进行对比，直接让模式串的指针按next表跳转到下一个位置，因为next数组当中存储的数值为2，所以模式串跳转到下标为2的地方进行对比。（图片引用自代码随想录28.strStr）。

在这里插入图片描述

  其中n为文本串长度，m为模式串长度，因为在匹配的过程中，根据前缀表不断调整匹配的位置，可以看出匹配的过程是O(n)，之前还要单独生成next数组，时间复杂度是O(m)。所以整个KMP算法的时间复杂度是O(n+m)的。
复杂度分析：

  • 时间复杂度： O ( n + m ) O(n + m) O(n+m)，其中n为文本串长度，m为模式串长度，因为在匹配的过程中，根据前缀表不断调整匹配的位置，可以看出匹配的过程是O(n)，之前还要单独生成next数组，时间复杂度是O(m)。所以整个KMP算法的时间复杂度是O(n+m)的。
  • 空间复杂度： O ( m ) O(m) O(m)，需要额外的空间存放大小为m的数组。

  KMP的关键在于构建next数组，getNext函数用来计算最长公共前后缀。本文使用的是前缀表统一减一的方式，令模式串的首字符最长公共前缀为-1。对于KMP算法来说，前缀表无论是统一减一或者是不减一都只是一种实现方式，其核心仍然是KMP算法。程序当中，i代表是模式串子串的最右端字符，当字符不相等时使用while循环回退，字符相等时就令j++，同时将j的值记录在前缀表当中。
KMP算法程序：

	// KMP算法
    void getNext(int* next, const string& s) {
        int j = -1;
        next[0] = j;
        for (int i = 1; i < s.size(); i++) { // 注意i从1开始
            while (j >= 0 && s[i] != s[j + 1]) { // 前后缀不相同了或者没有最长公共前后缀
                j = next[j]; // 向前回退
            }
            if (s[i] == s[j + 1]) { // 找到相同的前后缀
                j++;
            }
            next[i] = j; // 将j（前缀的长度）赋给next[i]
            
        }
    }
    int strStr2(string haystack, string needle) {
        if (!needle.size()) return 0;
        int* next = new int[needle.size()];
        getNext(next, needle);
        //my_print(next, needle.size(), "前缀表：");
        int j = -1; // // 因为next数组里记录的起始位置为-1
        for (int i = 0; i < haystack.size(); i++) { // 注意i就从0开始
            while (j >= 0 && haystack[i] != needle[j + 1]) { // 不匹配
                j = next[j]; // j 寻找之前匹配的位置
            }
            if (haystack[i] == needle[j + 1]) { // 匹配，j和i同时向后移动
                j++; // i的增加在for循环里
            }
            if (j == (needle.size() - 1)) { // 文本串s里出现了模式串t
                return (i - needle.size() + 1);
            }
        }
        return -1;
    }

二、BM算法

  本节转载自从头到尾彻底理解KMP。
  1977年，德克萨斯大学的Robert S. Boyer教授和J Strother Moore教授发明了一种新的字符串匹配算法：Boyer-Moore算法，简称BM算法。该算法从模式串的尾部开始匹配，且拥有在最坏情况下O(N)的时间复杂度。在实践中，比KMP算法的实际效能高。BM算法定义了两个规则：

  • 坏字符规则：当文本串中的某个字符跟模式串的某个字符不匹配时，我们称文本串中的这个失配字符为坏字符，此时模式串需要向右移动，移动的位数 = 坏字符在模式串中的位置 - 坏字符在模式串中最右出现的位置。此外，如果"坏字符"不包含在模式串之中，则最右出现位置为-1。
  • 好后缀规则：当字符失配时，后移位数 = 好后缀在模式串中的位置 - 好后缀在模式串上一次出现的位置，且如果好后缀在模式串中没有再次出现，则为-1。
      下面举例说明BM算法。例如，给定文本串“HERE IS A SIMPLE EXAMPLE”，和模式串“EXAMPLE”，现要查找模式串是否在文本串中，如果存在，返回模式串在文本串中的位置。
    1. 首先，"文本串"与"模式串"头部对齐，从尾部开始比较。"S"与"E"不匹配。这时，“S"就被称为"坏字符”（bad character），即不匹配的字符，它对应着模式串的第6位。且"S"不包含在模式串"EXAMPLE"之中（相当于最右出现位置是-1），这意味着可以把模式串后移6-(-1)=7位，从而直接移到"S"的后一位。 在这里插入图片描述
    2. 依然从尾部开始比较，发现"P"与"E"不匹配，所以"P"是"坏字符"。但是，"P"包含在模式串"EXAMPLE"之中。因为“P”这个“坏字符”对应着模式串的第6位（从0开始编号），且在模式串中的最右出现位置为4，所以，将模式串后移6-4=2位，两个"P"对齐。
      在这里插入图片描述
      在这里插入图片描述
    3. 依次比较，得到 “MPLE”匹配，称为"好后缀"（good suffix），即所有尾部匹配的字符串。注意，“MPLE”、“PLE”、“LE”、"E"都是好后缀。
      在这里插入图片描述
    4. 发现“I”与“A”不匹配：“I”是坏字符。如果是根据坏字符规则，此时模式串应该后移2-(-1)=3位。问题是，有没有更优的移法？

      在这里插入图片描述
    5. 更优的移法是利用好后缀规则：当字符失配时，后移位数 = 好后缀在模式串中的位置 - 好后缀在模式串中上一次出现的位置，且如果好后缀在模式串中没有再次出现，则为-1。所有的“好后缀”（MPLE、PLE、LE、E）之中，只有“E”在“EXAMPLE”的头部出现，所以后移6-0=6位。可以看出，“坏字符规则”只能移3位，“好后缀规则”可以移6位。每次后移这两个规则之中的较大值。这两个规则的移动位数，只与模式串有关，与原文本串无关。
      在这里插入图片描述
    6. 继续从尾部开始比较，“P”与“E”不匹配，因此“P”是“坏字符”，根据“坏字符规则”，后移 6 - 4 = 2位。因为是最后一位就失配，尚未获得好后缀。
      在这里插入图片描述
        由上可知，BM算法不仅效率高，而且构思巧妙，容易理解。

三、Sunday算法

  KMP算法并不比最简单的c库函数strstr()快多少，而BM算法虽然通常比KMP算法快，但BM算法也还不是现有字符串查找算法中最快的算法，本文最后再介绍一种比BM算法更快的查找算法即Sunday算法。Sunday算法由Daniel M.Sunday在1990年提出，它的思想跟BM算法很相似：只不过Sunday算法是从前往后匹配，在匹配失败时关注的是文本串中参加匹配的最末位字符的下一位字符。

  • 如果该字符没有在模式串中出现则直接跳过，即移动位数 = 匹配串长度 + 1；
  • 否则，其移动位数 = 模式串中最右端的该字符到末尾的距离+1。
    // Sunday算法
    int find_single_char(char c, const string& needle) {   
        for (int i = needle.size() - 1; i >= 0; --i) {  // 找最右端的字符，因此从后往前循环
            if (c == needle[i]) return i; 
        }
        return -1;
    }
    int strStr3(string haystack, string needle) {
        if (haystack.size() < needle.size()) return -1;     // 检查合法性
        if (!needle.size()) return 0;                       // needle为空返回0      
        for (int i = 0; i <= haystack.size() - needle.size(); ) {
            for (int j = 0; j < needle.size(); ++j) {
                if (needle[j] != haystack[i + j]) {     // 匹配失败                
                    int k = find_single_char(haystack[i + needle.size()], needle);   // 文本字符串末尾的下一位字符串
                    if (k == -1)   i += needle.size() + 1;  // 模式串向右移动 模式串长度 + 1 
                    else i += needle.size() - k;            // 向右移动 模式串最右端的该字符到末尾的距离+1
                    break;
                }     
                if (j == needle.size() - 1) return i;   // 匹配成功
            }
        }
        return -1;
    }

  除了上面一个版本的代码之外，笔者还写了另外一个版本的代码。可以观察到，我们通过find_single_char这个函数去查找字符串是否存在这个字符的效率是比较低的。想要快速的查找一个元素是否在一个字符串当中，不得不考虑用哈希表。字符串在编译器内存是使用ASCII码，因此我们建立一个ASCII码表数组，提前计算出模式串的偏移量，代码如下：

    // 查找算法用哈希表代替的Sunday算法   
    int strStr4(string haystack, string needle) {
        if (haystack.size() < needle.size()) return -1;     // 检查合法性
        if (!needle.size()) return 0;                       // needle为空返回0  

        int shift_table[128] = { 0 };       // 128为ASCII码表长度
        for (int i = 0; i < 128; i++) {     // 偏移表默认值设置为 模式串长度 + 1
            shift_table[i] = needle.size() + 1;
        }
        for (int i = 0; i < needle.size(); i++) {
            shift_table[needle[i]] = needle.size() - i;
        }

        int s = 0, j; // 文本串初始位置
        while (s <= haystack.size() - needle.size()) {
            j = 0;
            while (haystack[s + j] == needle[j]) { 
                ++j;
                if (j >= needle.size()) return s;   // 匹配成功
            }
            // 找到主串中当前跟模式串匹配的最末字符的下一个字符
            // 在模式串中出现最后的位置
            // 所需要从(模式串末尾+1)移动到该位置的步数
            s += shift_table[haystack[s + needle.size()]];
        }
        return -1;
    }

复杂度分析：

  • 时间复杂度： 平均时间复杂度为 O ( n ) O(n) O(n)，最坏情况时间复杂度为 O ( n ∗ m ) O(n*m) O(n∗m)。
  • 空间复杂度： O ( 1 ) O(1) O(1)，常量存储空间。

四、完整代码

  代码当中包含了暴力穷解法、KMP算法、Sunday算法。

# include <iostream>
# include <string>
using namespace std;

void my_print(int* arr, int arr_len, string str) {
    cout << str << endl;
    for (int i = 0; i < arr_len; ++i) {
        cout << arr[i] << ' ';
    }
    cout << endl;
}

class Solution {
public:
	// 暴力穷解
	// 复杂度n * m
	int strStr(string haystack, string needle) {
		if (haystack.size() < needle.size()) return -1;	
		if (!needle.size()) return 0; // needle为空返回0
		for (int i = 0; i < haystack.size(); ++i) {
			string substr = haystack.substr(i, needle.size());
			if (!needle.compare(substr)) return i;
		}
		return -1;
	}

	// KMP算法
    void getNext(int* next, const string& s) {
        int j = -1;
        next[0] = j;
        for (int i = 1; i < s.size(); i++) { // 注意i从1开始
            while (j >= 0 && s[i] != s[j + 1]) { // 前后缀不相同了
                j = next[j]; // 向前回退
            }
            if (s[i] == s[j + 1]) { // 找到相同的前后缀
                j++;
            }
            next[i] = j; // 将j（前缀的长度）赋给next[i]
            
        }
    }
    int strStr2(string haystack, string needle) {
        if (needle.size() == 0) {
            return 0;
        }
        int* next = new int[needle.size()];
        //int next[needle.size()]; 
        getNext(next, needle);
        //my_print(next, needle.size(), "前缀表：");
        int j = -1; // // 因为next数组里记录的起始位置为-1
        for (int i = 0; i < haystack.size(); i++) { // 注意i就从0开始
            while (j >= 0 && haystack[i] != needle[j + 1]) { // 不匹配
                j = next[j]; // j 寻找之前匹配的位置
            }
            if (haystack[i] == needle[j + 1]) { // 匹配，j和i同时向后移动
                j++; // i的增加在for循环里
            }
            if (j == (needle.size() - 1)) { // 文本串s里出现了模式串t
                return (i - needle.size() + 1);
            }
        }
        return -1;
    }

    // Sunday算法
    int find_single_char(char c, const string& needle) {   
        for (int i = needle.size() - 1; i >= 0; --i) {  // 找最右端的字符，因此从后往前循环
            if (c == needle[i]) return i; 
        }
        return -1;
    }
    int strStr3(string haystack, string needle) {
        if (haystack.size() < needle.size()) return -1;     // 检查合法性
        if (!needle.size()) return 0;                       // needle为空返回0      
        for (int i = 0; i <= haystack.size() - needle.size(); ) {
            for (int j = 0; j < needle.size(); ++j) {
                if (needle[j] != haystack[i + j]) {     // 匹配失败                
                    int k = find_single_char(haystack[i + needle.size()], needle);   // 文本字符串末尾的下一位字符串
                    if (k == -1)   i += needle.size() + 1;  // 模式串向右移动 模式串长度 + 1 
                    else i += needle.size() - k;            // 向右移动 模式串最右端的该字符到末尾的距离+1
                    break;
                }     
                if (j == needle.size() - 1) return i;   // 匹配成功
            }
        }
        return -1;
    }

    // 查找算法用哈希表代替的Sunday算法   
    int strStr4(string haystack, string needle) {
        if (haystack.size() < needle.size()) return -1;     // 检查合法性
        if (!needle.size()) return 0;                       // needle为空返回0  

        int shift_table[128] = { 0 };       // 128为ASCII码表长度
        for (int i = 0; i < 128; i++) {     // 偏移表默认值设置为 模式串长度 + 1
            shift_table[i] = needle.size() + 1;
        }
        for (int i = 0; i < needle.size(); i++) {
            shift_table[needle[i]] = needle.size() - i;
        }

        int s = 0, j; // 文本串初始位置
        while (s <= haystack.size() - needle.size()) {
            j = 0;
            while (haystack[s + j] == needle[j]) { 
                ++j;
                if (j >= needle.size()) return s;   // 匹配成功
            }
            // 找到主串中当前跟模式串匹配的最末字符的下一个字符
            // 在模式串中出现最后的位置
            // 所需要从(模式串末尾+1)移动到该位置的步数
            s += shift_table[haystack[s + needle.size()]];
        }
        return -1;
    }
};

int main()
{
	//string haystack = "sadbutsad";
	//string needle = "sad";
	//string haystack = "abc";
	//string needle = "c";
    //string haystack = "substring searching algorithm";
    //string needle = "search";
    //string haystack = "hello";
    //string needle = "ll";
    //string haystack = "mississippi";
    //string needle = "issi";
    string haystack = "aabaaaababaababaa";
    string needle = "bbbb";
	int k = 2;
	Solution s1;
	cout << "目标字符串：\n" << "“" << haystack << "”" << endl;
	int result = s1.strStr4(haystack, needle);
	cout << "查找子串结果：\n" << result << endl;
	system("pause");
	return 0;
}

参考博文：

晚安66
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构与算法之字符串匹配算法
weixin_47225948的博客
09-20 822
字符串匹配算法是在一个文本串中寻找一个模式串出现的算法。其基本原理是在文本串中逐个比较模式串的字符，如果匹配则继续比较下一个字符，如果不匹配则将模式串向右移动一位，继续比较。以下是一些常用的字符串匹配算法：暴力匹配法（Brute Force）：从文本串的第一个字符开始，逐个比较模式串和文本串中的字符，如果不匹配则将模式串向右移动一位，继续比较。KMP算法（Knuth-Morris-Pratt）：利用模式串本身的特点，在匹配失败时不回溯文本串，而是回溯模式串，让其尽量多地向右移动一位，以提高匹配效率。
【数据结构】字符串匹配（暴力匹配）
debug...
10-29 1233
字符串查找-暴力破解
这可能是全网最好的字符串匹配算法讲解
最新发布
2401_83916241的博客
04-08 988
面试是跳槽涨薪最直接有效的方式，马上金九银十来了，各位做好面试造飞机，工作拧螺丝的准备了吗？掌握了这些知识点，面试时在候选人中又可以夺目不少，暴击9999点。机会都是留给有准备的人，只有充足的准备，才可能让自己可以在候选人中脱颖而出。《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》点击传送门即可获取！om: 33%;" />面试是跳槽涨薪最直接有效的方式，马上金九银十来了，各位做好面试造飞机，工作拧螺丝的准备了吗？
字符串匹配
llkkhjh的博客
12-04 649
简单介绍了字符串匹配的几种算法
六种字符串匹配算法详解（含代码演示）
Guqing_f的博客
05-08 5776
1. Brute-Force算法 2. Rabin-Karp Hash算法 3. Kmp算法 4. Kmp的优化算法 5. Sunday算法 6. Shift-And算法 ps：字符串匹配其实是单模匹配问题 1.Brute-Force 朴素匹配算法（暴力匹配） 时间复杂度：O(n*m) //返回 文本串s中第一次查找到模式串t的位置 int brute_force(const char *s, const char *t){ //扫描文本串的每一位 for(int i = 0; s[i];
动态规划 | 带有通配符的字符串匹配
zwz2011303359的博客
07-17 2573
动态规划 | 带有通配符的字符串匹配（浅显易懂） 时间：2015-08-15 06:46:15      阅读：5178      评论：0      收藏：0      [点我收藏+] 标签：动态规划   wildcard   leetcode   字符串匹配   通配符    带有通配符的字符串匹配 一、Leetcode | 44 Wildcard Matching（只有一个字符串包含...
基于字符串模式匹配算法的病毒感染检测问题_算法_数据结构_
09-30
基于字符串模式匹配算法的病毒感染检测问题——C语言实现。
数据结构实验 串模式匹配算法
07-18
C/C++实现串匹配算法，包括源代码和实验报告。实现了串的创建，查看，修改，朴素的模式匹配算法，kmp算法和kmp改进算法。
数据结构与算法串.docx
01-18
数据结构与算法串是一种基础的数据结构，广泛应用于计算机科学和软件开发领域。下面是关于数据结构与算法串的知识点总结： 一、串的定义： 串是一种有限序列，组成元素可以是任意字符。串可以为空串，也可以是多个...
Java数据结构及算法实例：朴素字符匹配 Brute Force
09-03
朴素字符匹配，也称为Brute Force算法，是一种基础的字符串搜索方法。它的基本思想是对每一对主串（待查找的字符串）和模式串（要匹配的子串）进行逐字符的比较，直到找到匹配的子串或者遍历完所有可能的起始位置。...
数据与算法课件：5 字符串.pdf
06-26
在《数据结构与算法》中，字符串被视为一种非数值处理的数据类型，可以理解为数据元素为字符的线性表。 2. **特性**：字符串的长度是字符的数量，可以是零（空串，记为S=Ф 或 S=“”）。值得注意的是，字符的单...
Python字符串匹配----6种方法的使用
热门推荐
qq_34500270的博客
09-29 16万+
1. re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。 import re line="this hdr-biz 123 model server 456" pattern=r"123" matchObj = re.match( pattern, line) 2. re.search 扫描整个字符串并返回第一个成功的匹配...
字符串——字符串匹配
jiahonghao2002的博客
03-06 1445
文章目录字符串匹配导论一、基本概念字符串匹配问题符号和术语后缀重叠引理二、朴素字符串匹配算法三、Rabin-Karp算法 字符串匹配导论 一、基本概念 字符串匹配问题 假设文本是一个长度为nnn的数组T[1…n]T[1 \ldots n]T[1…n]，而模式是一个长度为mmm的数组P[1…m]P[1 \ldots m]P[1…m]，其中m≤nm \leq nm≤n，进一步假设PPP和TTT的元素都是来自一个有限的字母集∑\sum∑的字符。数组TTT和PPP通常被称为字符串。 如果0≤s≤n−m0 \leq
算法数据结构系列-理论篇-字符串匹配（一）
Tom-Stduio
06-25 1045
这里写自定义目录标题1、字符串匹配算法1.1 字符串匹配：BF 算法 字符串匹配算法很多，分为单模式串和多模式串匹配算法。其中，单模式串匹配算法即一个串跟一个串进行匹配，比如BF 算法、RK 算法、BM算法、KMP算法。多模式串匹配算法，也就是在一个串中同时查找多个串，比如Trie 树和 AC 自动机。 1.1 字符串匹配：BF 算法 BF 算法中的 BF 是 Brute Force 的缩写，中文叫作暴力匹配算法，也叫朴素匹配算法。 ....................................
我对kmp算法过程中k=next[k]的理解
半路上车的前端之旅
12-01 731
我对kmp算法过程中k=next[k]的理解 KMP算法最浅显理解——一看就明白 本文链接：https://blog.csdn.net/starstar1992/article/details/54913261 超详细理解：kmp算法next数组求解过程和回溯的含义 本文链接：https://blog.csdn.net/buppt/article/details/78531384 我是在看完这两篇...
字符串匹配常用算法
meixr的专栏
05-31 6773
字符串匹配（string match)是在实际工程中经常会碰到的问题，通常其输入是原字符串(String)和子串（又称模式，Pattern)组成，输出为子串在原字符串中的首次出现的位置。通常精确的字符串搜索算法包括暴力搜索(Brute force)，KMP, BM(Boyer Moore), sunday, robin-karp 以及 bitap。下面分析这几种方法并给出其实现。假设原字符串长度M，字串长度为N。1. Brute force.该方法又称暴力搜索，也是最容易想到的方法。预处理时间 O(0)匹配
数据结构与算法:字符串字符匹配
Jos's blogs
03-14 307
字符串
数据结构实验之串二：字符串匹配
Soleil的博客
08-03 3047
数据结构实验之串二：字符串匹配 Time Limit: 1000MS Memory limit: 65536K 题目描述   给定两个字符串string1和string2，判断string2是否为string1的子串。   输入  输入包含多组数据，每组测试数据包含两行，第一行代表string1，第二行代表string2，string1和string
串的匹配
anyi7265的博客
06-26 247
题目描述 给定两个字符串string1和string2，判断string2是否为string1的子串。 输入 输入包含多组数据，每组测试数据包含两行，第一行代表string1，第二行代表string2，string1和string2中保证不出现空格。 输出 对于每组输入数据，若string2是string1的子串，则输出"YES"，否则输出"...
数据结构与算法 - 字符串匹配
05-12
字符串匹配是指在一个主串中查找一个模式串的出现位置。在计算机领域中，字符串匹配是一个重要的基础问题，应用广泛。常见的字符串匹配算法有暴力匹配、KMP算法、Boyer-Moore算法等。 暴力匹配算法是最简单的一种字符串匹配算法，也称为朴素匹配算法。其基本思想是：从主串的第一个字符开始，与模式串的第一个字符进行比较，若相等，则继续比较主串和模式串的下一个字符；若不相等，则从主串的第二个字符开始，再重新与模式串的第一个字符进行比较，以此类推，直到找到模式串在主串中的匹配位置或者主串被匹配完为止。 KMP算法是一种高效的字符串匹配算法。它利用模式串的自身匹配特性，在匹配过程中尽可能减少比较次数，从而提高匹配效率。具体思路是：在匹配过程中，当模式串与主串某个字符不匹配时，根据已匹配的前缀和后缀信息，将模式串向右移动一定的位数，从而跳过一些不必要的比较。 Boyer-Moore算法是一种基于坏字符和好后缀规则的字符串匹配算法。它通过预处理模式串，得到每个字符在模式串中最后出现的位置和好后缀的后缀子串在模式串中匹配的位置，从而在匹配过程中尽可能跳过多余的比较，提高匹配效率。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

晚安66

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值