字符串匹配与文本处理（七）：AC自动机

一碗黄焖鸡三碗米饭

已于 2025-06-19 17:50:57 修改

阅读量613

点赞数 18

CC 4.0 BY-SA版权

分类专栏：算法精要文章标签：算法开发语言数据结构 java AC自动机

于 2025-06-19 17:50:42 首次发布

本文链接：https://blog.csdn.net/sjdgehi/article/details/148741219

算法精要专栏收录该内容

105 篇文章

订阅专栏

字符串匹配与文本处理之AC自动机：深入解析与Java实现

6. AC自动机与其他字符串匹配算法的对比

7. 总结

字符串匹配算法在计算机科学中占据着至关重要的地位，广泛应用于文本搜索、数据处理、信息检索等多个领域。在这些算法中，AC自动机（Aho-Corasick Automaton）作为一种高效的多模式字符串匹配算法，尤其适用于多模式匹配问题。相比于传统的暴力匹配算法，AC自动机能够通过预处理阶段，显著减少匹配过程中的计算复杂度，提升搜索效率。

本文将深入讲解AC自动机的原理、实现过程，并通过Java代码实现一个完整的AC自动机多模式匹配算法。同时，我们还将对比其他常见的字符串匹配算法，帮助读者深入理解AC自动机的优势。

1. 什么是AC自动机？

AC自动机是一种用于多模式字符串匹配的自动机，它的核心思想是在文本中同时查找多个模式字符串。AC自动机结合了字典树（Trie）与失败指针（Failure Pointer）的概念，它能够在O(n)的时间复杂度下，完成多模式匹配任务。AC自动机的名字来源于其发明者Alfred V. Aho和Margaret J. Corasick。

1.1 字典树与失败指针

1.1.1 字典树（Trie）

字典树是一种树形结构，用于存储多个字符串。它的每个节点表示一个字符，根节点表示空字符串。通过字典树，我们可以高效地存储和匹配多个模式字符串。

1.1.2 失败指针

失败指针是AC自动机的一个创新，它类似于KMP算法中的“部分匹配表”。失败指针的作用是当在匹配过程中发生不匹配时，跳转到下一个可能的匹配位置。它避免了重复的匹配过程，从而提高了效率。

2. AC自动机的工作原理

AC自动机的工作过程可以分为两个阶段：

2.1 预处理阶段

构建字典树：将所有模式字符串插入到字典树中。每个模式字符串的字符逐个插入字典树，直到构建出一个完整的字典树结构。
构建失败指针：为字典树中的每个节点构建失败指针。失败指针的作用是当字符匹配失败时，指向一个可能的备选节点。失败指针的建立过程类似于BFS（广度优先搜索）。

2.2 匹配阶段

在匹配阶段，AC自动机会在文本字符串中进行匹配。如果当前字符匹配失败，算法会通过失败指针跳转到下一个可能匹配的位置，避免了重复的计算。最终，所有匹配到的模式字符串将被返回。

3. AC自动机的算法流程

构建字典树：逐个插入模式字符串，并建立字典树。
建立失败指针：通过广度优先搜索的方式，建立每个节点的失败指针。
文本匹配：遍历文本字符，利用字典树和失败指针进行匹配。

4. AC自动机的时间复杂度分析

预处理阶段：
- 构建字典树：对于每个模式字符串的长度为 m，若模式总数为 k，那么构建字典树的时间复杂度为 O(k * m)。
- 构建失败指针：使用广度优先搜索，时间复杂度为 O(k * m)。
匹配阶段：匹配阶段的时间复杂度为 O(n)，其中 n 是文本字符串的长度。每个文本字符都会通过字典树的跳转，匹配所有模式字符串。

因此，AC自动机在文本匹配的时间复杂度是 O(n)，这是它比暴力匹配和KMP算法更加高效的关键所在。

5. Java实现AC自动机

下面我们将通过Java代码实现AC自动机的多模式匹配。

5.1 定义字典树节点

首先，我们定义一个字典树节点类，它包含以下属性：

next[]：指向子节点的指针。
fail：失败指针，指向匹配失败时可能的节点。
output：该节点表示的字符串是否是一个模式字符串。

import java.util.*;

public class AhoCorasick {

    // 字典树节点类
    static class TrieNode {
        TrieNode[] next = new TrieNode[26];  // 假设只有26个小写字母
        TrieNode fail;                        // 失败指针
        List<Integer> output = new ArrayList<>(); // 保存匹配到的模式索引
    }

    // 根节点
    private TrieNode root = new TrieNode();

    // 1. 构建字典树
    public void buildTrie(String[] patterns) {
        for (int i = 0; i < patterns.length; i++) {
            String pattern = patterns[i];
            TrieNode node = root;

            for (int j = 0; j < pattern.length(); j++) {
                char ch = pattern.charAt(j);
                int index = ch - 'a'; // 假设字符都是小写字母

                if (node.next[index] == null) {
                    node.next[index] = new TrieNode();
                }

                node = node.next[index];
            }

            node.output.add(i);  // 将模式字符串的索引保存到该节点
        }
    }

    // 2. 构建失败指针
    public void buildFailure() {
        Queue<TrieNode> queue = new LinkedList<>();
        
        // 初始化根节点的失败指针
        for (int i = 0; i < 26; i++) {
            if (root.next[i] != null) {
                root.next[i].fail = root;
                queue.offer(root.next[i]);
            }
        }

        while (!queue.isEmpty()) {
            TrieNode node = queue.poll();

            for (int i = 0; i < 26; i++) {
                TrieNode child = node.next[i];
                if (child != null) {
                    TrieNode fail = node.fail;
                    while (fail != null && fail.next[i] == null) {
                        fail = fail.fail;
                    }

                    if (fail == null) {
                        child.fail = root;
                    } else {
                        child.fail = fail.next[i];
                        child.output.addAll(child.fail.output);  // 继承失败指针的输出
                    }

                    queue.offer(child);
                }
            }
        }
    }

    // 3. 匹配文本
    public List<Integer> search(String text) {
        List<Integer> result = new ArrayList<>();
        TrieNode node = root;

        for (int i = 0; i < text.length(); i++) {
            char ch = text.charAt(i);
            int index = ch - 'a';

            // 匹配失败，跳转失败指针
            while (node != root && node.next[index] == null) {
                node = node.fail;
            }

            if (node.next[index] != null) {
                node = node.next[index];
            }

            // 检查当前节点的输出
            if (!node.output.isEmpty()) {
                for (int patternIndex : node.output) {
                    result.add(patternIndex);  // 匹配到的模式索引
                }
            }
        }

        return result;
    }

    public static void main(String[] args) {
        AhoCorasick ac = new AhoCorasick();
        
        String[] patterns = {"he", "she", "his", "hers"};
        ac.buildTrie(patterns);   // 构建字典树
        ac.buildFailure();        // 构建失败指针

        String text = "ushers";
        List<Integer> result = ac.search(text);  // 执行匹配

        for (int idx : result) {
            System.out.println("Pattern found: " + patterns[idx]);
        }
    }
}

5.2 代码解释

构建字典树：buildTrie 方法将每个模式字符串逐字符插入字典树中，直到完整插入并标记该节点。
构建失败指针：buildFailure 方法使用BFS来构建每个节点的失败指针。
匹配文本：search 方法遍历文本字符串，利用字典树和失败指针进行多模式匹配。如果匹配到一个模式，则输出该模式的索引。

6. AC自动机与其他字符串匹配算法的对比

在实际应用中，AC自动机与其他字符串匹配算法（如KMP、Boyer-Moore等）有不同的适用场景。以下是不同算法的对比：

算法	最坏时间复杂度	平均时间复杂度	空间复杂度	优势
暴力匹配	O(n * m)	O(n * m)	O(1)	实现简单，但效率较低
KMP算法	O(n + m)	O(n + m)	O(m)	针对单个模式的匹配效率较高
Boyer-Moore	O(n * m)	O(n / m)	O(m)	对于单个模式非常高效
AC自动机	O(n)	O(n)	O(k * m)	对于多模式匹配效率极高，适用于模式数量较多的场景