28-📝数据结构与算法核心知识 | 字符串算法: 文本处理的核心算法理论与实践字符串算法是计算机科学中处理文本数据的核

mindmap
  root((字符串算法))
    理论基础
      定义与特性
        字符串匹配
        模式搜索
        文本处理
      历史发展
        1960s朴素算法
        1970s KMP
        1977年Boyer_Moore
    字符串匹配
      朴素算法
        Onm复杂度
        暴力匹配
      KMP算法
        前缀函数
        On加m
      Boyer_Moore
        坏字符规则
        好后缀规则
      Rabin_Karp
        滚动哈希
        哈希匹配
    字符串处理
      字符串哈希
        多项式哈希
        滚动哈希
      后缀数组
        排序后缀
        最长公共前缀
      后缀树
        压缩Trie
        线性时间构建
    字符串操作
      字符串编辑
        插入删除
        替换操作
      字符串转换
        大小写转换
        编码转换
    工业实践
      搜索引擎
        全文搜索
        模式匹配
      DNA序列
        序列比对
        模式搜索
      文本编辑器
        查找替换
        正则匹配

一、前言

1. 研究背景

字符串算法是计算机科学中处理文本数据的核心算法。从搜索引擎的全文搜索到DNA序列的比对，从编译器的词法分析到文本编辑器的查找替换，字符串算法无处不在。

根据Google的研究，字符串匹配是搜索引擎最频繁的操作之一。KMP、Boyer-Moore、Rabin-Karp等算法在文本处理、生物信息学、网络安全等领域有广泛应用。

2. 历史发展

1960s：朴素字符串匹配算法
1970年：KMP算法（Knuth-Morris-Pratt）
1977年：Boyer-Moore算法
1987年：Rabin-Karp算法
1990s至今：各种优化和变体

二、概述

1. 什么是字符串算法

字符串算法是处理字符串数据的算法，主要包括字符串匹配、字符串搜索、字符串比较等操作。

2. 字符串匹配问题的形式化定义

定义（根据CLRS和字符串算法标准教材）：

字符串匹配问题：给定文本T[1..n]和模式P[1..m]，找到所有满足 $T[i..i+m-1] = P[1..m]$ 的位置i。

形式化表述：

设文本T和模式P都是字符集Σ上的字符串，字符串匹配函数为： $Match(T, P) = \{i | T[i..i+m-1] = P[1..m], 1 \leq i \leq n-m+1\}$

复杂度下界：

对于字符串匹配问题，任何算法在最坏情况下至少需要Ω(n+m)次字符比较。

学术参考：

CLRS Chapter 32: String Matching
Knuth, D. E., Morris, J. H., & Pratt, V. R. (1977). "Fast pattern matching in strings." SIAM Journal on Computing
Cormen, T. H., et al. (2009). Introduction to Algorithms (3rd ed.). MIT Press

3. 字符串匹配问题

问题定义：在文本T中查找模式P的所有出现位置。

输入：

文本T：长度为n的字符串
模式P：长度为m的字符串

输出：P在T中所有出现的位置

三、字符串匹配算法

1. 朴素算法（Naive Algorithm）

思想：逐个位置尝试匹配

伪代码：朴素算法

ALGORITHM NaiveSearch(text, pattern)
    n ← text.length
    m ← pattern.length
    results ← []
    
    FOR i = 0 TO n - m DO
        j ← 0
        WHILE j < m AND text[i + j] = pattern[j] DO
            j ← j + 1
        
        IF j = m THEN
            results.add(i)
    
    RETURN results

时间复杂度：O(n × m) 空间复杂度：O(1)

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

思想：利用已匹配信息，避免重复比较

伪代码：KMP算法

ALGORITHM KMPSearch(text, pattern)
    n ← text.length
    m ← pattern.length
    lps ← BuildLPS(pattern)  // 最长公共前后缀
    results ← []
    
    i ← 0  // text的索引
    j ← 0  // pattern的索引
    
    WHILE i < n DO
        IF text[i] = pattern[j] THEN
            i ← i + 1
            j ← j + 1
            
            IF j = m THEN
                results.add(i - j)
                j ← lps[j - 1]  // 继续查找下一个匹配
        ELSE
            IF j ≠ 0 THEN
                j ← lps[j - 1]  // 利用已匹配信息
            ELSE
                i ← i + 1
    
    RETURN results

ALGORITHM BuildLPS(pattern)
    m ← pattern.length
    lps ← Array[m]
    len ← 0
    i ← 1
    
    lps[0] ← 0
    
    WHILE i < m DO
        IF pattern[i] = pattern[len] THEN
            len ← len + 1
            lps[i] ← len
            i ← i + 1
        ELSE
            IF len ≠ 0 THEN
                len ← lps[len - 1]
            ELSE
                lps[i] ← 0
                i ← i + 1
    
    RETURN lps

时间复杂度：O(n + m) 空间复杂度：O(m)

3. Boyer-Moore算法

思想：从右到左匹配，利用坏字符和好后缀规则跳跃

伪代码：Boyer-Moore算法

ALGORITHM BoyerMooreSearch(text, pattern)
    n ← text.length
    m ← pattern.length
    badChar ← BuildBadCharTable(pattern)
    goodSuffix ← BuildGoodSuffixTable(pattern)
    results ← []
    
    s ← 0  // 文本中的偏移
    
    WHILE s ≤ n - m DO
        j ← m - 1
        
        // 从右到左匹配
        WHILE j ≥ 0 AND pattern[j] = text[s + j] DO
            j ← j - 1
        
        IF j < 0 THEN
            results.add(s)
            // 好后缀规则：移动到下一个可能的匹配位置
            s ← s + (m - goodSuffix[0] IF m > 1 ELSE 1)
        ELSE
            // 坏字符规则
            badCharShift ← j - badChar[text[s + j]]
            // 好后缀规则
            goodSuffixShift ← goodSuffix[j]
            s ← s + max(badCharShift, goodSuffixShift)
    
    RETURN results

ALGORITHM BuildBadCharTable(pattern)
    m ← pattern.length
    badChar ← Array[256]  // ASCII字符集
    
    FOR i = 0 TO 255 DO
        badChar[i] ← -1
    
    FOR i = 0 TO m - 1 DO
        badChar[pattern[i]] ← i
    
    RETURN badChar

时间复杂度：

最好：O(n/m)
最坏：O(n × m)
平均：O(n)

4. Rabin-Karp算法

思想：使用滚动哈希快速比较

伪代码：Rabin-Karp算法

ALGORITHM RabinKarpSearch(text, pattern)
    n ← text.length
    m ← pattern.length
    results ← []
    
    // 计算模式和文本第一个窗口的哈希值
    patternHash ← Hash(pattern)
    textHash ← Hash(text[0..m-1])
    
    // 滚动哈希
    FOR i = 0 TO n - m DO
        IF patternHash = textHash THEN
            // 验证（避免哈希冲突）
            IF text[i..i+m-1] = pattern THEN
                results.add(i)
        
        // 滚动到下一个窗口
        IF i < n - m THEN
            textHash ← RollHash(textHash, text[i], text[i+m], m)
    
    RETURN results

ALGORITHM Hash(str)
    hash ← 0
    base ← 256
    mod ← 101  // 大质数
    
    FOR EACH char IN str DO
        hash ← (hash * base + char) % mod
    
    RETURN hash

ALGORITHM RollHash(oldHash, oldChar, newChar, patternLen)
    base ← 256
    mod ← 101
    basePower ← Power(base, patternLen - 1) % mod
    
    // 移除最左边的字符，添加新字符
    newHash ← ((oldHash - oldChar * basePower) * base + newChar) % mod
    
    IF newHash < 0 THEN
        newHash ← newHash + mod
    
    RETURN newHash

时间复杂度：

平均：O(n + m)
最坏：O(n × m)（哈希冲突）

四、字符串哈希

多项式哈希

伪代码：多项式哈希

ALGORITHM PolynomialHash(str, base, mod)
    hash ← 0
    
    FOR EACH char IN str DO
        hash ← (hash * base + char) % mod
    
    RETURN hash

滚动哈希

应用：快速计算子串哈希值

伪代码：滚动哈希

ALGORITHM RollingHash(text, windowSize)
    base ← 256
    mod ← 1000000007
    basePower ← Power(base, windowSize - 1) % mod
    
    hash ← Hash(text[0..windowSize-1])
    results ← [hash]
    
    FOR i = windowSize TO text.length - 1 DO
        // 移除最左边的字符
        hash ← (hash - text[i-windowSize] * basePower) % mod
        IF hash < 0 THEN
            hash ← hash + mod
        
        // 添加新字符
        hash ← (hash * base + text[i]) % mod
        results.add(hash)
    
    RETURN results

五、后缀数组与后缀树

后缀数组（Suffix Array）

定义：字符串所有后缀按字典序排序后的数组

伪代码：构建后缀数组

ALGORITHM BuildSuffixArray(str)
    n ← str.length
    suffixes ← []
    
    // 生成所有后缀
    FOR i = 0 TO n - 1 DO
        suffixes.add((str[i..], i))
    
    // 按字典序排序
    Sort(suffixes)
    
    // 提取索引
    suffixArray ← []
    FOR EACH (suffix, index) IN suffixes DO
        suffixArray.add(index)
    
    RETURN suffixArray

应用：

最长公共子串
最长重复子串
字符串匹配

最长公共前缀（LCP）

伪代码：计算LCP数组

ALGORITHM BuildLCPArray(str, suffixArray)
    n ← str.length
    lcp ← Array[n]
    rank ← Array[n]
    
    // 计算rank数组
    FOR i = 0 TO n - 1 DO
        rank[suffixArray[i]] ← i
    
    l ← 0
    FOR i = 0 TO n - 1 DO
        IF rank[i] = n - 1 THEN
            l ← 0
            CONTINUE
        
        j ← suffixArray[rank[i] + 1]
        
        WHILE i + l < n AND j + l < n AND 
              str[i + l] = str[j + l] DO
            l ← l + 1
        
        lcp[rank[i]] ← l
        
        IF l > 0 THEN
            l ← l - 1
    
    RETURN lcp

六、工业界实践案例

案例1：搜索引擎的全文搜索

背景：Google、百度等搜索引擎需要快速匹配搜索关键词。

技术方案：

倒排索引：词 → 文档列表
字符串匹配：快速查找关键词
相关性排序：TF-IDF等算法

伪代码：搜索引擎匹配

ALGORITHM SearchEngineMatch(query, documents)
    // 分词
    keywords ← Tokenize(query)
    results ← []
    
    FOR EACH keyword IN keywords DO
        // 使用KMP或Boyer-Moore匹配
        matches ← KMPSearch(documents, keyword)
        results.add(matches)
    
    // 合并结果并排序
    merged ← MergeResults(results)
    SortByRelevance(merged)
    RETURN merged

案例2：DNA序列比对

背景：生物信息学需要比对DNA序列。

应用：序列相似度、模式搜索

伪代码：DNA序列匹配

ALGORITHM DNASequenceMatch(sequence, pattern)
    // DNA序列：A, T, G, C
    // 使用字符串匹配算法
    matches ← BoyerMooreSearch(sequence, pattern)
    
    // 计算相似度
    similarity ← CalculateSimilarity(sequence, pattern, matches)
    RETURN (matches, similarity)

案例3：文本编辑器的查找替换

背景：文本编辑器需要快速查找和替换文本。

应用：实时搜索、批量替换

伪代码：文本编辑器查找

ALGORITHM TextEditorSearch(text, pattern, caseSensitive)
    IF caseSensitive THEN
        RETURN KMPSearch(text, pattern)
    ELSE
        // 转换为小写后搜索
        lowerText ← ToLower(text)
        lowerPattern ← ToLower(pattern)
        matches ← KMPSearch(lowerText, lowerPattern)
        RETURN matches

3. 案例3：正则表达式引擎（Perl/Python实践）

背景：正则表达式需要匹配复杂模式。

技术实现分析（基于Perl和Python的正则表达式引擎）：

正则表达式匹配：
- 应用场景：模式匹配、文本验证、数据提取
- 算法选择：使用NFA（非确定性有限自动机）或DFA（确定性有限自动机）
- 性能优化：使用回溯算法，支持复杂模式
实际应用：
- Perl：使用优化的正则表达式引擎
- Python re模块：使用回溯算法实现正则匹配
- JavaScript：V8引擎使用优化的正则表达式引擎

性能数据（Python测试，1MB文本）：

方法	简单模式	复杂模式	说明
匹配时间	10ms	100ms	可接受
内存占用	基准	+50%	可接受
功能支持	基础	完整	支持所有特性

学术参考：

Thompson, K. (1968). "Programming Techniques: Regular expression search algorithm." Communications of the ACM
Python Documentation: re module
Perl Documentation: Regular Expressions

伪代码：简单正则匹配（简化）

ALGORITHM SimpleRegexMatch(text, pattern)
    // 简化版：只支持 . 和 *
    RETURN RegexMatchRecursive(text, pattern, 0, 0)

FUNCTION RegexMatchRecursive(text, pattern, i, j)
    IF j = pattern.length THEN
        RETURN i = text.length
    
    // 处理 * 匹配
    IF j + 1 < pattern.length AND pattern[j + 1] = '*' THEN
        // 匹配0个或多个
        IF RegexMatchRecursive(text, pattern, i, j + 2) THEN
            RETURN true
        
        WHILE i < text.length AND 
              (pattern[j] = '.' OR text[i] = pattern[j]) DO
            i ← i + 1
            IF RegexMatchRecursive(text, pattern, i, j + 2) THEN
                RETURN true
        
        RETURN false
    
    // 处理单个字符匹配
    IF i < text.length AND 
       (pattern[j] = '.' OR text[i] = pattern[j]) THEN
        RETURN RegexMatchRecursive(text, pattern, i + 1, j + 1)
    
    RETURN false

七、总结

字符串算法是文本处理的核心，从简单的朴素匹配到高效的KMP、Boyer-Moore算法，从字符串哈希到后缀数组，不同的算法适用于不同的场景。从搜索引擎到DNA序列，从文本编辑器到编译器，字符串算法在多个领域都有重要应用。

关键要点

算法选择：根据文本特征选择合适算法
性能优化：KMP、Boyer-Moore等优化算法
实际应用：搜索引擎、生物信息学、文本处理
持续学习：关注新的字符串算法和优化技术

八、优缺点分析

朴素算法

优点：实现简单缺点：时间复杂度O(nm)，效率低

KMP算法

优点：O(n+m)时间复杂度，稳定缺点：需要预处理，实现复杂

Boyer-Moore算法

优点：平均性能优秀，跳跃距离大缺点：最坏情况O(nm)，实现复杂

Rabin-Karp算法

优点：实现简单，适合多模式匹配缺点：可能哈希冲突，最坏情况O(nm)

梦想从学习开始，事业从实践起步：理论是基础，实践是关键，持续学习是成功之道。

数据结构与算法是计算机科学的基础，是软件工程师的核心技能。本系列文章旨在复习数据结构与算法核心知识，为人工智能时代,接触AIGC、AI Agent，与AI平台、各种智能半智能业务场景的开发需求做铺垫:

其它专题系列文章

1. 前知识

2. 基于OC语言探索iOS底层原理

3. 基于Swift语言探索iOS底层原理

关于函数、枚举、可选项、结构体、类、闭包、属性、方法、swift多态原理、String、Array、Dictionary、引用计数、MetaData等Swift基本语法和相关的底层原理文章有如下几篇:

28-📝数据结构与算法核心知识 | 字符串算法: 文本处理的核心算法理论与实践

目录