Java 数据结构 - 字典树（Trie）

Java 中的字典树（Trie）：高效的字符串检索结构

1. 引言

字典树，也称为前缀树或 Trie（取自"retrieval"的中间音节），是一种树形数据结构，用于高效地存储和检索字符串数据集中的键。这种数据结构在处理字符串时表现出色，特别是在需要快速前缀匹配的场景中。本文将介绍字典树的概念、Java 实现以及其在实际应用中的优势。

2. 字典树的基本概念

2.1 结构特点

• 根节点不包含字符，除根节点外每个节点都只包含一个字符
• 从根节点到某一节点，路径上经过的字符连接起来，为该节点对应的字符串
• 每个节点的所有子节点包含的字符都不相同

2.2 主要操作

1. 插入字符串
2. 查找字符串
3. 字符串前缀匹配

3. Java 实现字典树

3.1 定义节点类

class TrieNode {
    private TrieNode[] children;
    private boolean isEndOfWord;

    TrieNode() {
        children = new TrieNode[26]; // 假设只包含小写字母
        isEndOfWord = false;
    }
}

3.2 实现 Trie 类

public class Trie {
    private TrieNode root;

    public Trie() {
        root = new TrieNode();
    }

    // 插入单词
    public void insert(String word) {
        TrieNode current = root;
        for (char ch : word.toCharArray()) {
            int index = ch - 'a';
            if (current.children[index] == null) {
                current.children[index] = new TrieNode();
            }
            current = current.children[index];
        }
        current.isEndOfWord = true;
    }

    // 搜索单词
    public boolean search(String word) {
        TrieNode node = searchNode(word);
        return node != null && node.isEndOfWord;
    }

    // 检查是否有以给定前缀开头的单词
    public boolean startsWith(String prefix) {
        return searchNode(prefix) != null;
    }

    private TrieNode searchNode(String str) {
        TrieNode current = root;
        for (char ch : str.toCharArray()) {
            int index = ch - 'a';
            if (current.children[index] == null) {
                return null;
            }
            current = current.children[index];
        }
        return current;
    }
}

4. 字典树的优势

1. 高效的字符串检索：查找的时间复杂度为 O(m)，其中 m 是要查找的字符串的长度。
2. 前缀匹配：可以轻松找到具有共同前缀的所有字符串。
3. 空间优化：对于有大量共同前缀的字符串集合，Trie 可以节省存储空间。

5. 应用场景

1. 自动完成：在搜索引擎、IDE 等场景中提供单词自动完成功能。
2. 拼写检查：快速验证单词是否正确拼写。
3. IP 路由表：在网络路由中使用。
4. 字符串排序：可以用于字符串的字典序排序。

6. 实际应用示例

6.1 单词搜索游戏

以下是一个使用 Trie 实现简单单词搜索游戏的示例：

import java.util.*;

public class WordSearchGame {
    private Trie dictionary;
    private Set<String> foundWords;

    public WordSearchGame() {
        dictionary = new Trie();
        foundWords = new HashSet<>();
    }

    public void addWordsToDictionary(List<String> words) {
        for (String word : words) {
            dictionary.insert(word.toLowerCase());
        }
    }

    public List<String> findWords(char[][] board) {
        List<String> result = new ArrayList<>();
        int m = board.length;
        int n = board[0].length;
        boolean[][] visited = new boolean[m][n];

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                dfs(board, visited, i, j, "", result);
            }
        }

        return result;
    }

    private void dfs(char[][] board, boolean[][] visited, int i, int j, String str, List<String> result) {
        if (i < 0 || j < 0 || i >= board.length || j >= board[0].length || visited[i][j]) {
            return;
        }

        str += board[i][j];

        if (!dictionary.startsWith(str)) {
            return;
        }

        if (dictionary.search(str) && !foundWords.contains(str)) {
            result.add(str);
            foundWords.add(str);
        }

        visited[i][j] = true;
        dfs(board, visited, i+1, j, str, result);
        dfs(board, visited, i-1, j, str, result);
        dfs(board, visited, i, j+1, str, result);
        dfs(board, visited, i, j-1, str, result);
        visited[i][j] = false;
    }

    public static void main(String[] args) {
        WordSearchGame game = new WordSearchGame();
        game.addWordsToDictionary(Arrays.asList("cat", "dog", "tac", "god", "act"));

        char[][] board = {
            {'c', 'a', 't'},
            {'r', 'r', 'e'},
            {'t', 'o', 'n'}
        };

        List<String> foundWords = game.findWords(board);
        System.out.println("Found words: " + foundWords);
    }
}

这个示例展示了如何使用 Trie 来实现一个简单的单词搜索游戏。游戏首先将一系列单词添加到字典树中，然后在给定的字符网格中搜索这些单词。

7. 字典树的局限性

1. 空间消耗：对于不共享前缀的字符串集合，Trie 可能消耗大量内存。
2. 不适合动态数据：如果需要频繁地插入和删除字符串，维护 Trie 的代价可能较高。

8. 优化方向

1. 压缩前缀树：合并只有一个子节点的节点，可以减少内存使用。
2. Ternary Search Tree：每个节点有三个子节点，可以在某些情况下提供更好的平衡。
3. 使用哈希表：在每个节点使用哈希表而不是数组来存储子节点，可以处理更大的字符集。

9. 总结

字典树是一种强大的数据结构，特别适合处理字符串集合。它在字符串检索和前缀匹配方面表现出色，广泛应用于自动完成、拼写检查等场景。尽管在某些情况下可能消耗较多内存，但其高效的检索性能使其成为处理字符串数据的重要工具。在 Java 中实现字典树相对简单，可以根据具体需求进行定制和优化。理解和掌握字典树的原理和实现对于解决字符串相关问题非常有帮助。