模式匹配是字符串处理中的核心问题，其目标是在主串 `t` 中定位子串 `s`（即模式）的出现位-优快云博客

本文链接：https://blog.youkuaiyun.com/blog_programb/article/details/148814228

模式匹配的定义

模式匹配是指在主串 ( t ) 中查找子串 ( s ) 的过程，其中子串 ( s ) 也被称为模式。如果在主串 ( t ) 中找到了子串 ( s )，则返回子串 ( s ) 在主串 ( t ) 中的起始位置（通常从0或1开始计数，具体取决于语言或算法的约定）；如果没有找到，则返回 -1 或其他表示失败的值。

关键点

主串 ( t ) 和子串 ( s )
- 主串 ( t ) 是被搜索的字符串，子串 ( s ) 是需要在主串中查找的模式。
- 例如，主串 ( t = “abcdefgh” )，子串 ( s = “cde” )。
匹配成功
- 如果子串 ( s ) 在主串 ( t ) 中完全匹配，返回子串 ( s ) 在主串 ( t ) 中的起始位置。
- 例如，对于上述例子，子串 ( s = “cde” ) 在主串 ( t = “abcdefgh” ) 中的起始位置是 2（假设从0开始计数）。
匹配失败
- 如果子串 ( s ) 在主串 ( t ) 中找不到匹配的部分，则返回 -1 或其他约定的失败值。
- 例如，如果子串 ( s = “xyz” )，主串 ( t = “abcdefgh” )，则返回 -1。

常见的模式匹配算法

暴力匹配法（Brute Force）
- 逐个字符比较主串和子串，直到找到匹配或遍历完主串。
- 时间复杂度为 ( O(n \times m) )，其中 ( n ) 是主串长度，( m ) 是子串长度。
KMP（Knuth-Morris-Pratt）算法
- 利用部分匹配表（Next数组）来避免重复比较，提高效率。
- 时间复杂度为 ( O(n + m) )。
Rabin-Karp 算法
- 利用哈希函数快速比较子串，适合多模式匹配。
- 平均时间复杂度为 ( O(n + m) )，但在最坏情况下可能退化为 ( O(n \times m) )。
Boyer-Moore 算法
- 通过坏字符规则和好后缀规则从右向左比较，跳过大量不必要的比较。
- 在实际应用中效率很高，但最坏情况下时间复杂度为 ( O(n \times m) )。

模式匹配的基本概念与原理

模式匹配是字符串处理中的核心问题，其目标是在主串 t 中定位子串 s（即模式）的出现位置。以下从多个维度深入解析这一概念：

一、核心要素与定义

主串（Text String）：待搜索的长字符串，记为 t，长度为 n。
模式串（Pattern String）：需要查找的子串，记为 s，长度为 m。
匹配成功：若 s 是 t 的子串，返回 s 在 t 中首次出现的起始位置（通常从0或1开始计数）。
匹配失败：若 s 不存在于 t 中，返回 -1 或特定标识。

二、常见模式匹配算法

以下是几种经典算法的对比，涵盖时间复杂度、核心思想及优缺点：

算法名称	时间复杂度	核心思想	优缺点
暴力匹配（BF）	最坏情况：O(n×m)	从主串头部开始，逐个字符对比模式串，不匹配时主串指针回退，模式串指针重置。	- 实现简单，但效率低，适用于短文本或简单场景。 - 当 `m` 较大时，性能急剧下降。
KMP算法	最优：O(n+m)	通过预处理模式串生成 `next` 数组，利用已匹配的前缀信息避免无效回溯。	- 高效处理长文本，尤其适用于模式串包含重复前缀的场景。 - 需额外空间存储 `next` 数组。
BM算法	平均：O(n/m)	从模式串尾部向前匹配，利用坏字符规则和好后缀规则跳跃式移动模式串。	- 在实际应用中通常比KMP更快，尤其适合模式串较长的场景。 - 预处理逻辑较复杂。
Sunday算法	平均：O(n)	从模式串头部匹配，根据当前字符的下一个字符决定跳跃距离，逻辑简洁高效。	- 实现比BM简单，性能接近BM，适用于英文文本等场景。 - 对中文等字符集支持需特殊处理。

三、暴力匹配算法示例（Python实现）

以下是暴力匹配的直观实现，便于理解模式匹配的基本逻辑：

def brute_force_match(t, s):
    """
    暴力匹配主串t中的模式串s
    t: 主串，s: 模式串
    返回s在t中的起始位置，未匹配返回-1
    """
    n, m = len(t), len(s)
    if m == 0:
        return 0  # 空串特殊处理
    if n < m:
        return -1  # 主串长度不足，直接失败
    
    i = 0  # 主串指针
    while i <= n - m:
        j = 0  # 模式串指针
        while j < m and t[i + j] == s[j]:
            j += 1
        if j == m:
            return i  # 匹配成功，返回起始位置
        i += 1  # 主串指针后移
    return -1  # 未找到匹配

四、KMP算法核心优化——`next`数组

KMP算法的关键在于通过 next 数组记录模式串的前缀后缀匹配关系，避免无效回溯。以模式串 s = "ababc" 为例：

next数组定义：next[j] 表示 s[0...j-1] 的最长相等前缀和后缀的长度。
计算示例：
- s = ["a", "b", "a", "b", "c"]
- next[0] = -1（边界条件），next[1] = 0（单个字符无前缀后缀）
- j=2时，子串 "ab" 的前缀 "a" 和后缀 "b" 不匹配，next[2] = 0
- j=3时，子串 "aba" 的最长相等前缀后缀为 "a"，长度1，next[3] = 1
- j=4时，子串 "abab" 的最长相等前缀后缀为 "ab"，长度2，next[4] = 2

五、应用场景

模式匹配在计算机科学中应用广泛：

文本编辑器：查找与替换功能（如Word、Notepad++）。
生物信息学：DNA序列中查找特定基因片段（如BLAST算法）。
网络安全：入侵检测系统（IDS）通过模式匹配识别恶意代码特征。
编译器：词法分析阶段识别标识符、关键字等模式。

六、延伸思考

多模式匹配：一次查找多个模式串（如AC自动机算法）。
近似匹配：允许一定误差的匹配（如编辑距离算法）。
并行计算优化：利用GPU加速大规模文本的模式匹配。
KMP（Knuth-Morris-Pratt）算法通过利用部分匹配表（也称为“前缀函数”或“Next数组”）来提高模式匹配的效率。它避免了暴力匹配法中常见的回溯问题，从而显著减少了不必要的比较。以下是KMP算法提高效率的关键点和详细解释：

1. 暴力匹配法的局限性

在暴力匹配法中，当主串和子串的某个字符不匹配时，子串需要回溯到下一个起始位置重新比较。例如：

主串：ABABABAC
子串：ABABAC

在暴力匹配中，当匹配到第6个字符时发现不匹配（C 不等于 A），子串需要回退到第2个字符重新开始匹配。这种回溯会导致大量重复比较，尤其是在主串和子串较长时效率很低。

2. KMP算法的核心思想

KMP算法的核心在于利用已匹配部分的信息，避免不必要的回溯。它通过构建一个“部分匹配表”（Next数组）来记录子串的前缀信息，从而在不匹配时直接跳过已知的匹配部分。

部分匹配表（Next数组）

部分匹配表是一个数组，用于记录子串中每个位置的最长相等前后缀长度。例如：

子串：ABABAC
部分匹配表：Next = [0, 0, 1, 2, 3, 0]

解释：

Next[0] = 0：空字符串没有前后缀。
Next[1] = 0：A 的最长相等前后缀长度为 0。
Next[2] = 1：AB 的最长相等前后缀长度为 1（A）。
Next[3] = 2：ABA 的最长相等前后缀长度为 2（AB）。
Next[4] = 3：ABAB 的最长相等前后缀长度为 3（ABA）。
Next[5] = 0：ABABA 的最长相等前后缀长度为 0（C 与前面的字符不匹配）。

如何利用部分匹配表

当主串和子串的某个字符不匹配时，KMP算法不会简单地将子串向右移动一位，而是根据部分匹配表直接跳过已知的匹配部分。例如：

主串：ABABABAC
子串：ABABAC
部分匹配表：Next = [0, 0, 1, 2, 3, 0]

假设匹配到第6个字符时发现不匹配（C 不等于 A），此时子串的当前匹配长度为3（Next[5] = 0，但前一个位置的值是3）。根据部分匹配表，子串可以直接跳到第4个字符（Next[3] = 2），而不是从头开始匹配。

3. KMP算法的步骤

KMP算法分为两部分：

构建部分匹配表（Next数组）
匹配过程

构建部分匹配表（Next数组）

def build_next_array(pattern):
    n = len(pattern)
    next_array = [0] * n  # 初始化Next数组
    j = 0  # j表示最长相等前后缀的长度
    for i in range(1, n):
        while j > 0 and pattern[i] != pattern[j]:
            j = next_array[j - 1]  # 回退到前一个匹配位置
        if pattern[i] == pattern[j]:
            j += 1
        next_array[i] = j
    return next_array

匹配过程

def kmp_search(text, pattern):
    n = len(text)
    m = len(pattern)
    next_array = build_next_array(pattern)
    j = 0  # j表示当前匹配的子串位置
    for i in range(n):
        while j > 0 and text[i] != pattern[j]:
            j = next_array[j - 1]  # 回退到前一个匹配位置
        if text[i] == pattern[j]:
            j += 1
        if j == m:  # 匹配成功
            return i - m + 1  # 返回子串在主串中的起始位置
    return -1  # 匹配失败