【LeetCode热题100道笔记】实现 Trie (前缀树)

题目描述

Trie（发音类似 “try”）或者说 前缀树 是一种树形数据结构，用于高效地存储和检索字符串数据集中的键。这一数据结构有相当多的应用情景，例如自动补全和拼写检查。

请你实现 Trie 类：

• Trie() 初始化前缀树对象。
• void insert(String word) 向前缀树中插入字符串 word 。
• boolean search(String word) 如果字符串 word 在前缀树中，返回 true（即，在检索之前已经插入）；否则，返回 false 。
• boolean startsWith(String prefix) 如果之前已经插入的字符串 word 的前缀之一为 prefix ，返回 true ；否则，返回 false 。

示例：

输入
[“Trie”, “insert”, “search”, “search”, “startsWith”, “insert”, “search”]
[[], [“apple”], [“apple”], [“app”], [“app”], [“app”], [“app”]]
输出
[null, null, true, false, true, null, true]

解释
Trie trie = new Trie();
trie.insert(“apple”);
trie.search(“apple”); // 返回 True
trie.search(“app”); // 返回 False
trie.startsWith(“app”); // 返回 True
trie.insert(“app”);
trie.search(“app”); // 返回 True

提示：
1 <= word.length, prefix.length <= 2000
word 和 prefix 仅由小写英文字母组成
insert、search 和 startsWith 调用次数 总计 不超过 3 * 104 次

思考：前缀树（Trie）的核心设计逻辑

前缀树的本质是用“树的层级结构”映射“字符串的字符序列”，核心目标是通过“共享公共前缀”减少空间冗余，同时实现高效的字符串插入、查询和前缀匹配。
优化设计的核心思路可概括为：

1. 根节点空字符化：根节点不存储任何字符，仅作为所有字符串的公共起点，避免因首字符不同导致的结构冗余；
2. 字符节点化：将字符串的每个字符封装为一个节点，节点间通过“父子关系”对应字符的先后顺序（如“apple”对应 根→a→p→p→l→e 的节点链）；
3. 结束标记显式化：每个节点添加 isEnd 标记，明确区分“该节点是某个完整单词的结尾”还是“仅作为其他单词的前缀”（如“app”和“apple”共享“app”前缀，需通过 isEnd 标记“app”的结尾节点）；
4. 子节点高效检索：每个节点的子节点通过“字符匹配”快速定位（如用数组或哈希表存储子节点，避免遍历查找，优化性能）。

前缀树核心操作（插入/查询/前缀匹配）的算法过程

以下以“标准前缀树”（根节点为空、节点含 isEnd 标记）为例，详细描述三大核心操作的算法过程：

一、初始化（Trie 构造函数）

目标：创建前缀树的根节点，奠定整个树的结构基础。

1. 定义节点结构 TreeNode：包含三个属性
   • val：存储当前节点的字符（根节点为 null）；
   • children：存储子节点的集合（推荐用哈希表 Map 或长度为26的数组，便于快速匹配字符）；
   • isEnd：布尔值，标记当前节点是否为某个完整单词的结尾。
2. 构造前缀树实例时，初始化根节点为 new TreeNode(null)（空字符根节点）。

二、插入操作（insert 方法）

目标：将字符串的每个字符逐次添加到前缀树中，形成完整的字符链，并标记单词结尾。
算法过程：

1. 从根节点开始，初始化当前节点 currentNode = 根节点；
2. 遍历待插入字符串的每个字符 char：
   a. 检查 currentNode 的子节点集合中，是否存在以 char 为值的子节点；
   b. 若不存在：创建新节点 new TreeNode(char)，并将其加入 currentNode 的子节点集合；
   c. 若存在：直接获取该子节点；
   d. 将 currentNode 指向该子节点（移动到下一层，准备处理下一个字符）；
3. 遍历结束后，将最终的 currentNode 的 isEnd 设为 true（标记该节点是当前单词的结尾）。

示例：插入“apple”

• 路径：根节点 → a（新节点）→ p（新节点）→ p（新节点）→ l（新节点）→ e（新节点）；
• 最终将“e”节点的 isEnd 设为 true。

三、查询完整单词（search 方法）

目标：判断字符串是否完整存在于前缀树中（需确保最后一个字符对应节点的 isEnd 为 true）。
算法过程：

1. 从根节点开始，初始化当前节点 currentNode = 根节点；
2. 遍历待查询字符串的每个字符 char：
   a. 检查 currentNode 的子节点集合中，是否存在以 char 为值的子节点；
   b. 若不存在：说明字符串不存在，直接返回 false；
   c. 若存在：将 currentNode 指向该子节点，继续处理下一个字符；
3. 遍历结束后，判断最终 currentNode 的 isEnd 是否为 true：
   • 若是：返回 true（字符串完整存在）；
   • 若否：返回 false（仅为前缀，非完整单词）。

示例：查询“app”（已插入“apple”）

• 遍历路径：根节点 → a → p → p；
• 最终“p”节点的 isEnd 为 false（仅为“apple”的前缀），故返回 false。

四、前缀匹配（startsWith 方法）

目标：判断字符串是否为前缀树中某个单词的前缀（无需关心是否为完整单词）。
算法过程：

1. 从根节点开始，初始化当前节点 currentNode = 根节点；
2. 遍历待匹配前缀的每个字符 char：
   a. 检查 currentNode 的子节点集合中，是否存在以 char 为值的子节点；
   b. 若不存在：说明前缀不存在，返回 false；
   c. 若存在：将 currentNode 指向该子节点，继续处理下一个字符；
3. 遍历结束后：直接返回 true（只要能完整遍历前缀字符，说明存在对应的前缀）。

示例：匹配“app”（已插入“apple”）

• 遍历路径：根节点 → a → p → p；
• 完整遍历前缀字符，返回 true（无需关心“p”节点是否为单词结尾）。

优化点与性能分析

1. 子节点存储优化：
   • 若仅处理小写英文字母，可用长度为26的数组存储子节点（索引对应 charCodeAt(0) - 'a'.charCodeAt(0)），访问时间复杂度 O(1)；
   • 若处理任意字符（如大写、符号），可用 Map 存储子节点（键为字符，值为节点），灵活性更高。
2. 时间复杂度：
   • 插入、查询、前缀匹配的时间复杂度均为 O(L)（L 为字符串长度），仅需遍历一次字符串；
3. 空间复杂度：
   • 最坏情况（所有字符串无公共前缀）为 O(N×L)（N 为字符串数量，L 为平均长度）；
   • 存在公共前缀时，空间会大幅节省（如“apple”和“apply”共享“appl”前缀，仅多存储“e”和“y”两个节点）。

通过以上设计，前缀树在字符串检索场景（如搜索引擎自动补全、拼写检查）中能兼顾效率与空间，是典型的“空间换时间”数据结构。

代码

/**
 * 前缀树节点结构：包含字符、子节点数组、单词结束标记
 */
function TreeNode(val) {
    this.val = val;         // 存储单个字符
    this.children = [];     // 子节点数组（存储TreeNode）
    this.isEnd = false;     // 标记是否为某个单词的结尾
}

/**
 * 前缀树（Trie）实现
 */
var Trie = function() {
    this.root = new TreeNode(null);  // 根节点为一空节点（不存储字符）
};

/**
 * 插入单词到前缀树
 * @param {string} word - 要插入的单词
 * @return {void}
 */
Trie.prototype.insert = function(word) {
    let node = this.root;  // 从根节点开始遍历
    for (let i = 0; i < word.length; i++) {
        const char = word[i];
        // 检查当前节点的子节点中是否已存在该字符
        let child = node.children.find(c => c.val === char);
        if (!child) {
            // 不存在则创建新节点，加入子节点数组
            child = new TreeNode(char);
            node.children.push(child);
        }
        // 移动到子节点，继续处理下一个字符
        node = child;
    }
    // 标记当前节点为单词的结尾
    node.isEnd = true;
};

/**
 * 查找单词是否在前缀树中（必须是完整单词）
 * @param {string} word - 要查找的单词
 * @return {boolean} - 是否存在该单词
 */
Trie.prototype.search = function(word) {
    let node = this.root;
    for (let i = 0; i < word.length; i++) {
        const char = word[i];
        const child = node.children.find(c => c.val === char);
        if (!child) {
            // 中途找不到对应字符，直接返回false
            return false;
        }
        node = child;
    }
    // 遍历完所有字符后，判断当前节点是否为单词结尾
    return node.isEnd;
};

/**
 * 查找是否存在以指定前缀开头的单词
 * @param {string} prefix - 要查找的前缀
 * @return {boolean} - 是否存在该前缀
 */
Trie.prototype.startsWith = function(prefix) {
    let node = this.root;
    for (let i = 0; i < prefix.length; i++) {
        const char = prefix[i];
        const child = node.children.find(c => c.val === char);
        if (!child) {
            // 中途找不到对应字符，返回false
            return false;
        }
        node = child;
    }
    // 只要能遍历完所有前缀字符，就说明存在该前缀
    return true;
};

/**
 * 示例用法：
 * var obj = new Trie()
 * obj.insert("apple")
 * console.log(obj.search("apple"));   // true
 * console.log(obj.search("app"));     // false（不是完整单词）
 * console.log(obj.startsWith("app")); // true（存在前缀）
 * obj.insert("app")
 * console.log(obj.search("app"));     // true（现在是完整单词）
 */