字符串算法

于 2024-08-22 10:11:20 发布
阅读量427 收藏 6
点赞数 26
分类专栏： # 字符串算法 文章标签： 算法 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LS_Ai/article/details/141420422
版权

目录

1. 引言

2. 基础概念

3. 字符串匹配算法

朴素匹配算法

KMP（Knuth-Morris-Pratt）算法

Boyer-Moore算法

1. 引言

简述字符串算法的重要性 字符串是计算机科学中的基本数据结构，广泛应用于文本处理、数据分析、网络安全等领域。有效的字符串算法可以极大地提高这些应用的效率和性能，因此对这些算法的理解和掌握至关重要。

常见的字符串处理任务

  • 匹配：查找一个字符串是否存在于另一个字符串中。
  • 搜索：在大量字符串中快速找到目标字符串。
  • 排序：根据字典序或其他规则对字符串数组进行排序。
  • 压缩：减少字符串的存储空间。

2. 基础概念

字符串的定义与表示 字符串是由字符组成的有限序列，通常用于表示文本数据。字符串可以用不同的编码方式进行存储和处理，如ASCII和Unicode。

ASCII码与Unicode

  • ASCII码：采用7位或8位二进制编码，用于表示英文字符及常用符号。
  • Unicode：一种通用的字符编码标准，可以表示几乎所有语言的字符，常用的编码方式包括UTF-8、UTF-16等。

字符串的基本操作

  • 连接：将两个或多个字符串拼接成一个新字符串。
  • 截取：从字符串中提取一个子字符串。
  • 查找：寻找某个子字符串在字符串中的位置。
  • 替换：将字符串中的某个子字符串替换为另一个字符串。

3. 字符串匹配算法

朴素匹配算法

算法原理

朴素匹配算法（Naive String Matching Algorithm）是一种最简单的字符串匹配算法，其核心思想是逐个字符地比较目标字符串（Text）中的每一个子串与模式字符串（Pattern），直到找到匹配的子串或遍历完整个目标字符串。

算法步骤

  1. 将目标字符串的第一个字符与模式字符串的第一个字符进行比较。
  2. 如果匹配，继续比较下一个字符；如果不匹配，从目标字符串的下一个字符开始重新比较。
  3. 重复上述步骤，直到找到匹配或遍历完整个目标字符串。

代码示例

python语言：

def naive_string_matcher(text, pattern):
    n = len(text)
    m = len(pattern)
    for i in range(n - m + 1):
        match = True
        for j in range(m):
            if text[i + j] != pattern[j]:
                match = False
                break
        if match:
            print(f"Pattern found at index {i}")

# 示例使用
text = "ABCDEFABCDEF"
pattern = "CDE"
naive_string_matcher(text, pattern)

C语言：

# include <stdio.h>
# include <stdlib.h>

typedef struct String {
    char *data;
    int len;
}String;

String *initString(){
    String *s = (String *)malloc(sizeof(String));
    s->data = NULL;
    s->len = 0;
    return s;
}

void stringAssign(String *s, char *data){
    // 释放字符串结构体中的数据内存
    if (s -> data) {
        free(s -> data);
    }
    int len = 0;
    // 将指针 data 的值赋给指针 temp，使得 temp 指向 data 所指向的内存地址。
    char* temp = data;
    // 通过遍历字符串中的每个字符，直到遇到字符串结束符'\0'，
    //每遍历一个字符，长度计数器len就增加1。
    while (*temp) {
        len++;
        temp++;
    }

    if (len == 0){
        s -> data = NULL;
        s -> len = 0;
    }
    else{
        temp = data;
        s -> len = len;
        s -> data = (char *)malloc((len + 1) * sizeof(char));
        for (int i = 0; i <= len; i++,temp++){
            s -> data[i] = *temp;
        }

    }
}

void printString(String *s){
    // 打印字符串的函数，接受一个指向String结构体的指针作为参数
    // 遍历字符串中的每个字符，使用箭头连接并打印出来
    for (int i = 0; i < s -> len; i++){
        printf(i == 0 ? "%c " : "-> %c", s -> data[i]);
    }
    printf("\n");
}

void forceMatch(String *master, String *sub){
    // 字符串匹配的暴算法，接受两个指向String结构体的指针作为参数
    int i = 0,j = 0;
    while (i < master -> len && j < sub -> len){    
        if (master -> data[i] == sub -> data[j]){
            i++;
            j++;
        }
        else{
            // 匹配失败，重置i(回到起点的下一位)，j，继续匹配
            i = i - j + 1;
            j = 0;
        }
    }
    if (j == sub -> len){
        printf("force Match success!\n");
    }
    else{
        printf("force Match fail!\n");
    }
}

int main(){
    String *s1 = initString();
    String *s2 = initString();
    stringAssign(s1, "hello world");
    stringAssign(s2, "world");
    printString(s1);
    printString(s2);
    forceMatch(s1, s2);
    return 0;
}

输出结果

Pattern found at index 2
Pattern found at index 8

时间复杂度分析 朴素匹配算法的时间复杂度取决于目标字符串的长度 n 和模式字符串的长度 m：

  • 最坏情况：O((n - m + 1) * m)，即在每个位置都进行完全比较。
  • 最优情况：O(n)，即模式字符串在目标字符串的开头找到。

案例分析 考虑一个实际应用场景，比如在一个长文章中搜索某个特定的词语。在这样的场景下，朴素匹配算法虽然简单，但在大多数情况下效率较低，尤其是当目标字符串和模式字符串都很长时。

图解说明 可以通过图示展示朴素匹配算法的逐步匹配过程。在下图中，每行代表一次新的比较，绿色表示成功匹配的字符，红色表示匹配失败后重新开始。

总结 朴素匹配算法虽然易于理解和实现，但在处理大型数据集时性能不佳。因此，通常会使用更为复杂和高效的算法，如KMP算法或Boyer-Moore算法。

KMP（Knuth-Morris-Pratt）算法

算法背景与概述 KMP算法是由Donald Knuth、Vaughan Pratt和James H. Morris在1977年提出的一种字符串匹配算法。KMP算法通过预处理模式字符串来避免在匹配过程中对目标字符串的字符进行重复比较，从而提高匹配效率。

部分匹配表（前缀表）的构建 KMP算法的核心在于部分匹配表（又称为前缀表）的构建。该表用于记录模式字符串中每个位置的最长相同前缀与后缀的长度，从而在模式字符串出现部分匹配时，能够快速跳转至下一个可能匹配的位置。

构建步骤

  1. 初始化前缀表，长度为模式字符串的长度。
  2. 遍历模式字符串，对于每个位置计算最长相同前缀与后缀的长度，并存入前缀表中。

代码示例：前缀表构建

def build_prefix_table(pattern):
    m = len(pattern)
    prefix_table = [0] * m
    j = 0  # length of the previous longest prefix suffix
    i = 1

    while i < m:
        if pattern[i] == pattern[j]:
            j += 1
            prefix_table[i] = j
            i += 1
        else:
            if j != 0:
                j = prefix_table[j - 1]
            else:
                prefix_table[i] = 0
                i += 1
    return prefix_table

# 示例使用
pattern = "ABABCABAB"
prefix_table = build_prefix_table(pattern)
print("Prefix Table:", prefix_table)

输出结果

Prefix Table: [0, 0, 1, 2, 0, 1, 2, 3, 2]

算法步骤

  1. 使用前缀表进行模式匹配，比较目标字符串与模式字符串。
  2. 当出现部分匹配时，利用前缀表跳过一些无用的比较。
  3. 重复上述过程，直到找到匹配或遍历完整个目标字符串。

代码示例：KMP算法

python语言：

def KMP_search(text, pattern):
    n = len(text)
    m = len(pattern)
    prefix_table = build_prefix_table(pattern)
    i = 0  # index for text
    j = 0  # index for pattern

    while i < n:
        if pattern[j] == text[i]:
            i += 1
            j += 1
        if j == m:
            print(f"Pattern found at index {i - j}")
            j = prefix_table[j - 1]
        elif i < n and pattern[j] != text[i]:
            if j != 0:
                j = prefix_table[j - 1]
            else:
                i += 1

# 示例使用
text = "ABABDABACDABABCABAB"
pattern = "ABABCABAB"
KMP_search(text, pattern)

C语言：

#include <stdio.h>
#include <stdlib.h>

typedef struct String
{
    char *data;
    int len;
} String;

String *initString()
{
    String *s = (String *)malloc(sizeof(String));
    s->data = NULL;
    s->len = 0;
    return s;
}

void stringAssign(String *s, char *data)
{
    if (s->data)
    {
        free(s->data);
    }

    int len = 0;
    char *temp = data;
    while (*temp)
    {
        len++;
        temp++;
    }

    if (len == 0)
    {
        s->data = NULL;
        s->len = 0;
    }
    else
    {
        temp = data;
        s->len = len;
        s->data = (char *)malloc(sizeof(char) * (len + 1));
        for (int i = 0; i < len; i++)
        {
            s->data[i] = *temp;
            temp++;
        }
    }
}

void printString(String *s)
{
    if (s->data)
    {
        for (int i = 0; i < s->len; i++)
        {
            printf(i == 0 ? "%c" : "-> %c", s->data[i]);
        }
    }
    printf("\n");
}

int *getNext(String *s)
{
    int *next = (int *)malloc(sizeof(int) * s->len);
    int i = 0, j = -1;
    next[0] = -1;
    while (i < s->len - 1)
    {
        if (j == -1 || s->data[i] == s->data[j])
        {
            i++;
            j++;
            next[i] = j;
        }
        else
        {
            j = next[j];
        }
    }
    return next;
}

void printNext(int *next, int len)
{
    for (int i = 0; i < len; i++)
    {
        printf(i == 0 ? "%d" : "-> %d", next[i]);
    }
    printf("\n");
}


void kmpMatch(String *master, String *sub, int* next){
    // 函数kmpMatch用于实现KMP字符串匹配算法
    // 参数master: 主字符串
    // 参数sub: 子字符串
    // 参数next: next数组，用于存储子字符串的最长公共前后缀长度
    int i = 0,j = 0;
    while (i < master->len && j < sub->len){
        if (j == -1 || master -> data[i] == sub -> data[j]){
            i++;
            j++;
        }else {
            j = next[j];
        }
    }
    if (j == sub->len){
        printf(" kmp match success. \n");
    }else{
        printf("kmp match fail. \n");
    }
}      


int main()
{
    String *s1 = initString();
    String *s2 = initString();
    stringAssign(s1, "hello world");
    stringAssign(s2, "world");

    printString(s1);

    int *next = getNext(s2);
    printNext(next, s2->len);
    kmpMatch(s1, s2, next);

    return 0;
}

输出结果

Pattern found at index 10

时间复杂度与空间复杂度分析

  • 时间复杂度：KMP算法的时间复杂度为O(n + m)，其中n为目标字符串的长度，m为模式字符串的长度。这是因为KMP算法通过前缀表避免了无用的重复比较，使得每个字符最多被比较两次。
  • 空间复杂度：前缀表的构建需要额外的O(m)空间，因此总的空间复杂度也是O(m)。

优缺点及应用场景

  • 优点：
    • KMP算法在匹配过程中不需要回溯，提高了匹配效率。
    • 适用于大规模文本搜索以及对时间复杂度要求较高的应用场景。
  • 缺点：
    • 前缀表的构建过程较为复杂，尤其是对于初学者而言。
  • 应用场景：
    • 文本编辑器中的查找替换功能。
    • DNA序列比对。
    • 网络爬虫中的网页内容查找。

推荐视频：

Boyer-Moore算法

算法特点 Boyer-Moore算法是另一种经典的字符串匹配算法，主要特点是从模式字符串的末尾开始向前匹配。该算法通过两个规则（坏字符规则和好后缀规则）来决定模式字符串的移动步数，从而大幅减少了比较次数。

算法步骤

  1. 坏字符规则：当模式字符串的一个字符与目标字符串的字符不匹配时，直接跳过坏字符在模式字符串中的所有出现位置，或将模式字符串移动到坏字符在模式字符串中最右的位置。
  2. 好后缀规则：当模式字符串的部分后缀与目标字符串的部分匹配时，利用模式字符串中的重复部分来跳过无用的匹配。
Jr_l
关注
  • 26
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C/C++ 检查一个字符串是否为另一个字符串的子字符串算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-27 7588
检查一个字符串是否为另一个字符串的子字符串的算法，可以使用两个指针来遍历两个字符串，同时比较对应位置上的字符是否相同，直到找到完全匹配或者其中一个字符串结束。
常用字符串算法
Elltor
05-29 3451
一、判断两个字符串是否包含相同的内容 1.巧用数组下标实现，把用字符的ASCII码值当作下标，记录出现的字符，然后对两字符串进行遍历 /** * 判断s于s2是否相同 * @param s * @param s2 * @return boolean */ static boolean equals(String s,Strin...
字符串算法——KMP算法C++详解
m0_54615144的博客
08-09 6971
简介 KMP 算法是 D.E.Knuth、J,H,Morris 和 V.R.Pratt 三位神人共同提出的，称之为 Knuth-Morria-Pratt 算法，简称 KMP 算法。该算法相对于 Brute-Force（暴力）算法有比较大的改进，主要是消除了主串指针的回溯，从而使算法效率有了某种程度的提高。...............
Leetcode刷题---字符串算法(三)
zhxxyb的博客
11-12 4390
本文是(第21讲) 字符串算法(三) - 字符串分割所涉及部分课后习题的解答，发帖来记录自己关于这些题的理解和做题过程中思路，如果有错误，欢迎批评指正。 1.最后一个单词的长度 题目：我们定义，在以下情况时，单词的大写用法是正确的：全部字母都是大写，比如 “USA” 。单词中所有字母都不是大写，比如 “leetcode” 。如果单词不只含有一个字母，只有首字母大写， 比如 “Google” 。给你一个字符串 word ，判断其中的单词大写用法是否正确。 主要思路：若对于字符串，所有字符都是大写或从第二个字符
【字符串】KMP算法
gzkeylucky的博客
09-11 1605
学习字符串KMP匹配算法
字符串常见算法整理
07-24 2720
文章目录单字符串问题：字符串反转回文判断截取字符（串）排列组合生成子串生成子序列字符串交互问题：（最长）公共字符串（最长）非递增（减）公共字符串N个字符串字符环（最长）公共子序列（最长）非递增（减）公共子序列N个字符串字符环超精度运算（数据结构的）巧妙设计搜索算法 单字符串问题： 字符串反转 回文判断 截取字符（串） 排列组合 生成子串 生成子序列 字符串交互问题：...
子字符串查找算法
无风听海
01-04 2509
一、什么是子字符串查找 子字符串查找是一种基本的字符串操作，是给定一段长度为N的文本和一个长度为M的模式（pattern）字符串，在文本中找到一个和该模式相符的子字符串的操作； 在实际的应用场景中，模式相对文本来说是很短的，即M远小于N，我们一般也会对模式进行预处理来支持在文本中的快速查找。 二、测试环境及基础类 开发语言使用的是C#； StringSearcher基础的基类，负责加载文件内容、字符串查找、性能测试等； public abstract class StringSearcher
KMP —— 字符串分析算法
三钻 - 之前端到全栈之路
11-30 8198
`快速`的从一个`主串`中找出一个你想要的`子串` —— 这里面的`主串`就是 `source 串`，而要寻找的 `子串` 就是 `pattern 串` 也叫 `模式串`。
字典树 —— 字符串分析算法
三钻 - 之前端到全栈之路
11-19 3332
这篇文章我们就来一起学习，剩下的几个字符串中比较细节的算法。
突破编程_C++_字符串算法（判断字符串是否包含）
突破编程
03-03 3475
C++ 字符串算法题：判断一个字符串（称为“主字符串”或“大字符串”）是否包含另一个字符串（称为“子字符串”或“小字符串”）的所有字符，且不论这些字符在主字符串中的顺序和连续性
1_金策_字符串算法选讲.pdf
02-16
字符串算法选讲 . . 字符串算法选讲 金策 清华大学交叉信息研究院 February 3, 2017 字符串算法选讲 Periods and borders Basics 字符串: s[1..n], |s| = n。 字符集: s[i] ∈ Σ。算法竞赛中常见的 Σ ...
java字符串相似度算法
09-03
Java字符串相似度算法是用于衡量两个字符串之间相似程度的一种计算方法。在文本处理、信息检索、数据清洗等领域中，这种算法具有重要的应用价值。这里主要介绍了一种基于Levenshtein距离的Java实现。 Levenshtein...
字符串BM算法
01-20
//构建坏字符哈希表,对应字符在模式串中的位置，如相同则靠最右 for(j = m -1; j >= 0; --j) //模式串从后往前匹配 { if(a[i+j] != b[j]) break; //坏字符对应模式串中的下标是j } 出现坏字符时对应模式串的...
Python查找最长不包含重复字符的子字符串算法示例
09-19
### Python查找最长不包含重复字符的子字符串算法详解 #### 一、问题背景与目标 在计算机科学领域，字符串处理是非常常见的任务之一。对于给定的字符串，如何找到其中最长的不包含重复字符的子字符串是一项典型的...
【Python】生成二维迷宫的算法
HarryXYC的博客
08-16 332
基于Pygame和PIL的迷宫生成器
C语言——函数递归
最新发布
2406_83392683的博客
08-18 367
递归是一种解决问题的方法，在C语言中，就是。但是，如果递归无限地进行下去，就会出现栈溢出，上述就是一个典型例子。
代码随想录算法训练营第十七天（二叉树 五）
b1ankwall的博客
08-16 780
参加代码随想录第43期算法训练营day17|654.最大二叉树，617.合并二叉树，700.二叉搜索树中的搜索，98.验证二叉搜索树
【算法】马踏棋盘（骑士周游）问题回溯算法实现以及使用贪心算法优化
2302_78914800的博客
08-18 555
将马儿随机放在国际象棋的 8*8 棋盘的某个方格中，马儿按照“马走日”进行移动，要求每个方格只进入一次，走遍棋盘上全部 64 个方格。注意：马儿不同的走法会得到不同的结果，效率也会有影响。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值