LeetCode刷题记录----208.实现前缀树(Medium)

于 2025-08-21 11:25:33 发布
阅读量420 收藏 7
点赞数 13
CC 4.0 BY-SA版权
分类专栏： 萘柰奈的LeetCode刷题记录 # 图论 文章标签： leetcode 算法 职场和发展
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/misco43/article/details/150577411

2025/8/21

题目（Medium）：

我的思路：

首先我们要知道前缀树是什么东西，前缀树就是指树中每一个节点的字符串值 = 它的父节点的字符串值 + 它与父节点连接的边的字符值。如下图所示：

图片和更详细的理解来自于这个博客：https://www.cnblogs.com/vincent1997/p/11237389.html

因此，对于这个树，我认为能够提前出三个数据：

  • ①节点自身的值
  • ②节点的每条边对应的字母值（可以是26个字母中任意一个）
  • ③节点每条边对应的子节点

其中数据②③可以结合在一起，让一个字母值对应一个子节点。

因此我们可以得到节点的数据结构TrieNode：

①节点自身的字符串值（string）

②节点每条边对应的子节点（unordered_map<char, TrieNode*>)

class TrieNode{
    public:
        string nodeStr;      //节点自身的值
        unordered_map<char, TrieNode*> edgeSon;   //节点的每个边代表的字母,以及其所对应的子节点

        TrieNode(string nodeStr){
            this->nodeStr = nodeStr;
        }
};

而对于具体的前缀树的实现如下：

1.初始化

从图中我们可以看到前缀树的头节点中的字符为空字符，因此前缀树中需要一个头节点数据。

同时还需要记录一个字符是否已经被插入，也可以用一个哈希集合来存储

class Trie {
private:
    TrieNode* head;  //前缀树头节点
    unordered_set<string> hasInsertStr; //已经被插入的字符串集合

public:
    //每个节点包含三个数据结构：①它的子边的字母 ②它的子节点 ③它自身的串
    Trie() {
        head = new TrieNode("");       //头节点自身的串值是空
    }

2.插入字符串

对于要插入的字符串，我们通过迭代器遍历它的每一个字符。然后判断该字符是否存在当前节点的哈希表中，如果不存在则创建该字符指向的节点。之后我们移动到该字符所指向的节点处

  void insert(string word) {
        //如果已经被插入过就不用再插入一次了
        if(search(word))
            return;

        //遍历每一个字串
        TrieNode* p = head;
        for(const auto& c: word){
            //先检索p所在节点是否存在该字母
            if(p->edgeSon.find(c) == p->edgeSon.end()){
                //如果还不存在就新创建一条该边和子节点
                p->edgeSon.insert({c, new TrieNode(p->nodeStr + c)});
            }
            //然后跳转到对应节点位置
            p = p->edgeSon[c];
        }

        //把新字符串插入到集合表中
        hasInsertStr.insert(word);
    }

3.检索字符串

直接在哈希集合中搜索是否存在即可

bool search(string word) {
        //返回是否找得到
        return hasInsertStr.find(word) != hasInsertStr.end();
    }

4.检索前缀和

和插入的思路差不多，也是遍历字符串获取每个字符，然后判断当前节点是否存在该字符对应的边。区别是如果不存在的话不是创建新的边和子节点，而是直接返回 false，如果能顺利遍历完则返回true

bool startsWith(string prefix) {
        if(search(prefix))
            return true;

        TrieNode* p = head;
        for(const auto& c : prefix){
            if(p->edgeSon.find(c) == p->edgeSon.end()){
                //如果发现其中有一个没找到的话，就说明这个字符不存在的
                return false;
            }
            else{
                //否则发现有则跳转到对应节点
                p = p->edgeSon[c];
            }   
        }
        //能完整检索完则说明存在的
        return true;
    }

完整代码如下：

class TrieNode{
    public:
        string nodeStr;      //节点自身的值
        unordered_map<char, TrieNode*> edgeSon;   //节点的每个边代表的字母,以及其所对应的子节点

        TrieNode(string nodeStr){
            this->nodeStr = nodeStr;
        }
};

class Trie {
private:
    TrieNode* head;  //前缀树头节点
    unordered_set<string> hasInsertStr; //已经被插入的字符串集合

public:
    //每个节点包含三个数据结构：①它的子边的字母 ②它的子节点 ③它自身的串
    Trie() {
        head = new TrieNode("");       //头节点自身的串值是空
    }
    
    void insert(string word) {
        //如果已经被插入过就不用再插入一次了
        if(search(word))
            return;

        //遍历每一个字串
        TrieNode* p = head;
        for(const auto& c: word){
            //先检索p所在节点是否存在该字母
            if(p->edgeSon.find(c) == p->edgeSon.end()){
                //如果还不存在就新创建一条该边和子节点
                p->edgeSon.insert({c, new TrieNode(p->nodeStr + c)});
            }
            //然后跳转到对应节点位置
            p = p->edgeSon[c];
        }

        //把新字符串插入到集合表中
        hasInsertStr.insert(word);
    }
    
    bool search(string word) {
        //返回是否找得到
        return hasInsertStr.find(word) != hasInsertStr.end();
    }
    
    bool startsWith(string prefix) {
        if(search(prefix))
            return true;

        TrieNode* p = head;
        for(const auto& c : prefix){
            if(p->edgeSon.find(c) == p->edgeSon.end()){
                //如果发现其中有一个没找到的话，就说明这个字符不存在的
                return false;
            }
            else{
                //否则发现有则跳转到对应节点
                p = p->edgeSon[c];
            }   
        }
        //能完整检索完则说明存在的
        return true;
    }
};

/**
 * Your Trie object will be instantiated and called as such:
 * Trie* obj = new Trie();
 * obj->insert(word);
 * bool param_2 = obj->search(word);
 * bool param_3 = obj->startsWith(prefix);
 */

时间复杂度：

  • 初始化O（1）
  • 插入O（L）【L为字符串长度】，
  • 检索字符串O（1）
  • 检索前缀和O（L）

空间复杂度：O（N·L^2)【因为可能插入N个单词，每个单词平均长度为L，因此对整个树的节点树最大可能是N·L，而每个节点又存储了自身对应的前缀和的字符串值，因此单个单词的路径和的空间复杂度可以达到O（L^2），而又有N个单词，所以达到了N·O（L^2)，取其中最大的主导向为O（N·L^2)】

优化思路：

很显然你可以发现一个事情，就是你在每一个节点中存储的该节点对应的前缀和其实并没有用到，这就浪费了空间了。还有就是字母是有顺序的，且固定为26个，因此完全可以用一个固定长度的数组（或者向量容器）来给每个节点标为额定的潜在边。且对于是否已经插入了该字符串，我们可以给每个节点都设定一个变量表示这个节点是否为某一个字符串的结尾处

因此，我们可以做出如下的优化：

①删去保存每个节点对应的前缀和的值的string变量

②用向量容器初始化为长度26，可以装载前缀树节点的一个变量

③给每个节点添加一个变量isEnd表示是否为某个字符串的末尾节点

1.初始化

初始化这里我们直接以Trie这个类下手，给他创建一个向量容器变量和一个isEnd变量。同时还提供一个能够帮助我们快速检索到前缀和字符串的末尾节点的方法。

//每个节点最多有26个可能的子节点（因为有二十六个字母），可以按顺序快速检索到
//每个节点可以标记是否为末尾节点表示它是否被插入

private:
    vector<Trie*> children; //孩子节点们
    bool isEnd;     //是否为末尾节点

    //传入一个前缀字符，尝试从该节点开始往后搜索到这个前缀字符的所在的节点
    Trie* findPrefix(string prefix){
        Trie* p = this;
        for(const auto& c : prefix){
            int index = c - 'a';
            if(p->children[index] == nullptr)
                return nullptr;
            else
                p = p->children[index];
        }
        return p;
    }

public:
    //更简洁的构造函数的写法
    // Trie() : children(26), isEnd(false){}
    
    Trie() {
        children = vector<Trie*>(26);
        isEnd = false;   
    }

①这里构造函数有更加简洁的写法。

②这里对向量初始化的时候不用new，因为 new的话是初始化一个指针了

③对于检索到前缀和的末尾节点，我们让每个字符-"a"可以得到该字符对应的索引位置（0~25）。然后如果能够完全遍历则可以到达并返回，否则中间找不到了就返回空指针。

④注意这里Trie*表示指向每一个节点的指针

2.插入字符串

这里的思路和上面找到前缀和末尾节点的差不多，只是这里如果发现对应的字母边指向空的话，就给他创建一个对应的节点对象

   
    void insert(string word) {
       //遍历每一个数字
       Trie* p = this;
       for(const auto& c : word){
            int index = c - 'a';
            //如果该字母还没有被初始化过，那就初始化它
            if(p->children[index] == nullptr){
                p->children[index] = new Trie();
            }
            //然后让p移动到下一个位置
            p = p-> children[index];
       }
       //最后一个到达的位置的isEnd设为真
       p->isEnd = true;
    }

同时记得遍历完毕后，把他实例化到达的最后一个节点的isEnd属性设置为true表示这个节点是该字符串的末尾位置

3.检索字符串

检索字符串就很简单了，可以把他当成一个前缀和去检索，只是这次检索到的前缀和的节点的isEnd属性要为true

bool search(string word) {
        Trie* node = findPrefix(word);
        return node != nullptr && node->isEnd;
    }

4.检索前缀和

我们上面已经实现过检索前缀和所在节点位置了，直接调用它看看返回的是否为空节点就好了

bool startsWith(string prefix) {
        return findPrefix(prefix) != nullptr;
    }

完整代码如下：

class Trie {
//每个节点最多有26个可能的子节点（因为有二十六个字母），可以按顺序快速检索到
//每个节点可以标记是否为末尾节点表示它是否被插入

private:
    vector<Trie*> children; //孩子节点们
    bool isEnd;     //是否为末尾节点

    //传入一个前缀字符，尝试从该节点开始往后搜索到这个前缀字符的所在的节点
    Trie* findPrefix(string prefix){
        Trie* p = this;
        for(const auto& c : prefix){
            int index = c - 'a';
            if(p->children[index] == nullptr)
                return nullptr;
            else
                p = p->children[index];
        }
        return p;
    }

public:
    //更简洁的构造函数的写法
    // Trie() : children(26), isEnd(false){}
    
    Trie() {
        children = vector<Trie*>(26);
        isEnd = false;   
    }
    
    void insert(string word) {
       //遍历每一个数字
       Trie* p = this;
       for(const auto& c : word){
            int index = c - 'a';
            //如果该字母还没有被初始化过，那就初始化它
            if(p->children[index] == nullptr){
                p->children[index] = new Trie();
            }
            //然后让p移动到下一个位置
            p = p-> children[index];
       }
       //最后一个到达的位置的isEnd设为真
       p->isEnd = true;
    }
    
    bool search(string word) {
        Trie* node = findPrefix(word);
        return node != nullptr && node->isEnd;
    }
    
    bool startsWith(string prefix) {
        return findPrefix(prefix) != nullptr;
    }
};

/**
 * Your Trie object will be instantiated and called as such:
 * Trie* obj = new Trie();
 * obj->insert(word);
 * bool param_2 = obj->search(word);
 * bool param_3 = obj->startsWith(prefix);
 */

时间复杂度：初始化O（1），其他操作O（L）【L是操作的字符串的长度】

空间复杂度：O(∣T∣⋅Σ)【T是插入的总字符串长度，Σ是字符集大小（这里为26）】

总结：

①对于要实现某个对象，我们需要先了解这个对象是什么，长什么样。然后才能确定具体去描述它的属性和方法

②对于有顺序和规律的边值（比如这里的字母），我们可以用固定长度的数组或者容器来简化地实现它

③对于每个节点，我们可以把他看成是默认有26个插槽，每次有需要的时候可以把它还没有插上的字母给插入到插槽中

leetcode刷题指南 - 两个月完成
iamjiangxiaoqian的博客
07-29 641
链表(8题) + 双指针(11题) = 19题。: 数据结构类(19题) = 19题。
算法笔记|leetcode刷题记录（C++）
JormungandrN的博客
06-11 626
刷题记录
LeetCode刷题记录----437.路径总和Ⅲ（medium）
misco43的博客
08-13 537
这篇文章探讨了两种解决二叉树路径和问题的算法。初始方案采用暴力双重递归，首先遍历每个节点作为路径起点，再递归计算其子树中满足目标值的路径数，时间复杂度较高。优化方案引入前缀和技巧，利用哈希表存储路径和，通过"当前前缀和-目标值"快速查找匹配路径，将时间复杂度降至O(N)。两种方法都采用深度优先搜索，但后者通过避免重复计算显著提升了效率。文章通过具体代码展示了两种实现方式，并强调了前缀和与哈希表在优化求和类问题中的重要作用。
LeetCode刷题记---2000/1414/1725
wr456wr的博客
02-06 476
(该模块仅为记录本人的leetcode的练习记录） 文章目录2000.反转单词前缀 2000.反转单词前缀 解题思路：先找到匹配的字符位置，若是不存在则直接返回源字符串，反正反转前部分。 代码： package LeetCode.Code2022.February; public class Solution2000 { public String reversePrefix(String word, char ch) { int index = -1; index =
leetcode刷题记录1-50-基于python
码python的Vinsmoke
05-06 680
1.两数之和-Easy class Solution(): def twoSum(self, nums, target): # nums: list->int # target: 两数之和 # 遍历数组每一个元素 for i in nums: # 计算另一个数 j = target - i # 记录下开始索引 start_index = nums.index(i) # 将i后面的数存放在一个临时list,防止出现6 = 3+3 temp = nu
LeetCode - 刷题记录
vcj1009784814的博客
02-11 906
LeetCode 203 移除链表元素 // 递归解法 class Solution { public ListNode removeElements(ListNode head, int val) { if(head == null) return null; ListNode tail = removeElements(head.next, val); if(head.val == val) return tail; head.ne
leetcode刷题记录
洪肥肥的博客
04-05 1833
刷题过程记录
leetcode竞赛记录-第62场双周赛
MichaelKongChina的博客
10-06 311
第62场双周赛记录得分排名情况赛题分析题一：将一维数组转变成二维数组（easy完成）题二：连接后等于目标字符串的字符串对（medium完成）题三：考试的最大困扰度（medium未完成）题四：分割数据的最多方案数（hard未完成）反思总结个人情况总结后续改进 得分排名情况 本次得分7分 本次排名1002/2619 leetcode竞赛全国排名：无 赛题分析 本次一共四题： 题一：将一维数组转变成二维数组（easy完成） 题二：连接后等于目标字符串的字符串对（medium完成） 题三：考试的最大困扰度（medi
LeetCode刷题笔记（Java实现）-- 3. 无重复字符的最长子串
qq_44392658的博客
01-23 557
题目难度：Medium 题目要求： 给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。 ##哈希集合 两个指针，分别表示子串的左右边界， 左指针不动，右指针不断右移，每次将一个字符加入哈希集合，并且判断，是否和原集合中的字符重复； 如果重复，就输出当前的非重复的字符长度，然后左指针右移一位，再寻找新的不重复的子串， 最后从所有不重复子串的长度中选出最长的长度返回。 /* * @lc app=leetcode.cn id=3 lang=java * * [3] 无重复字符的最长子串
leetcode题库-LeetCode:刷题记录
06-29
这是一份LeetCode的刷题记录。（This is a LeetCode brush code backup.） 数据结构 queue_stack包为队列和栈专题记录。 linked_list包为链表专题记录。 hash_table包为哈希表专题记录。 data_structure_binary_tree...
leetcode:leetcode刷题:pencil:
05-02
LeetCode Leetcode solutions in C++ 11 NO. Title Solution Note Difficulty Tag 1 Easy 数组 | 哈希表 2 Medium 链表 | 数学 3 Medium 字符串 4 Hard 数组 | 二分查找 5 Medium 字符串 | 动态规划 7 反转整数 C++ ...
蛇形矩阵leetcode-leetcode:Leetcode题解/刷题笔记。主要在中国站做题。非完全原创，参考了大量其他优秀题解
07-01
蛇形矩阵leetcode dingjianhub 的 leetcode 题解 写在前面 这里是 的 leetcode 刷题的笔记。 包含了已经提交的题目的代码、笔记。有些笔记较为详细，有些较为简略。 在这些笔记中，很多内容是参考、摘录、再创作了很...
Leetcode 16 java
AYheyheyhey的博客
08-18 681
迭代法：时间复杂度 O (n)（遍历一次链表），空间复杂度 O (1)（仅用 3 个指针），是更常用的解法（无递归栈开销）。递归法：时间复杂度 O (n)（递归 n 次），空间复杂度 O (n)（递归栈深度），思路更巧妙但需理解“回溯调整”。下次遇到链表操作，先想 “指针如何移动才能避免断裂”，多画几步流程（比如用草稿纸写 prev/curr/next 的变化），会比直接写代码更清晰～对比项翻转二叉树（递归）反转链表（迭代 / 递归）结构特性非线性（每个节点有两个分支）
力扣面试150(58/150)
2403_88913721的博客
08-17 453
本文介绍了一种翻转二叉树的递归解法。通过后序遍历的方式，先递归处理左右子树，再交换当前节点的左右孩子。算法时间复杂度为O(n)，空间复杂度为O(h)，其中h为树的高度。代码简洁明了，适用于任意结构的二叉树翻转。
leetcode 1277. 统计全为 1 的正方形子矩阵 中等
最新发布
2401_88085478的博客
08-20 103
正方形的总数 = 10 + 4 + 1 =正方形的总数 = 6 + 1 =的矩阵，矩阵中的元素不是。，请你统计并返回其中完全由。边长为 1 的正方形有。边长为 2 的正方形有。边长为 3 的正方形有。边长为 1 的正方形有。边长为 2 的正方形有。
leetcode热题100——day33
2302_80723133的博客
08-17 229
请你将所有链表合并到一个升序链表中，返回合并后的链表。给你一个链表数组，每个链表都已经按升序排列。
Leetcode 3652. Best Time to Buy and Sell Stock using Strategy
codename_cys的博客
08-19 265
Leetcode 3652. Best Time to Buy and Sell Stock using Strategy
LeetCode热题100--104. 二叉树的最大深度--简单
2301_80071187的博客
08-17 207
本文介绍了如何计算二叉树的最大深度。最大深度定义为从根节点到最远叶子节点的最长路径上的节点数。解决方案采用递归方法：若根节点为空返回0；否则递归计算左右子树的最大深度，取较大值加1（当前节点）作为结果。算法时间复杂度为O(n)，需要遍历所有节点。示例代码展示了Java实现，清晰地体现了分治思想：将问题分解为左右子树的子问题，合并结果得到最终解。
Leetcode 深度优先搜索 (6)
rainsky1992的博客
08-19 304
轴对称的定义：一棵二叉树是轴对称的，当且仅当它的左子树和右子树是镜像对称的。也就是说，左子树的结构和节点值与右子树完全对称。也可以用队列或栈进行迭代实现，原理类似，都是成对比较左右子树的对应节点。给你一个二叉树的根节点 root ， 检查它是否轴对称。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

萘柰奈

谢谢老板喵

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值