LeetCode-Trie树

已于 2022-02-18 11:00:18 修改
阅读量178 收藏
点赞数
分类专栏： # LeetCode-树 文章标签： leetcode 算法
于 2022-02-16 14:14:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hclbeloved/article/details/122962181
版权

1 Trie树

1.1 简介

        Trie 树，也叫“字典树”。顾名思义，它是一个树形结构。它是一种专门处理字符串匹配的数据结构，用来解决在一组字符串集合中快速查找某个字符串的问题。

1.2 实现

        Trie 树是一个多叉树，具体实现如下：

// TrieTree.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//
#include <string.h>

class Trie
{
public:
	Trie()
	{
		root = new TrieNode('/'); // 存储无意义字符
	}
	~Trie()
	{
		destroyTrieNode(root);
	}

	// 往Trie树中插入一个字符串
	void insert(const char *text)
	{
		TrieNode *p = root;
		for (int i = 0; i < strlen(text); ++i)
		{
			int index = text[i] - 'a';
			if (p->children[index] == NULL)
			{
				TrieNode *newNode = new TrieNode(text[i]);
				p->children[index] = newNode;
			}

			p = p->children[index];
		}
		p->isEndingChar = true;
	}

	// 在Trie树中查找一个字符串
	bool find(const char *pattern)
	{
		TrieNode *p = root;
		for (int i = 0; i < strlen(pattern); ++i)
		{
			int index = pattern[i] - 'a';
			if (p->children[index] == NULL)
			{
				return false; // 不存在pattern
			}

			p = p->children[index];
		}

		if (p->isEndingChar == false)
		{
			return false; // 不能完全匹配，只是前缀
		}
		else
		{
			return true; // 找到pattern
		}
	}

	//删除trie中的字符串时,把要删除的字符串在trie树中的ending标记删除就好了
	void del(const char *pattern)
	{
		TrieNode *p = root;
		for (int i = 0; i < strlen(pattern); ++i)
		{
			int index = pattern[i] - 'a';
			if (p->children[index] == NULL)
			{
				return; // 不存在pattern
			}

			p = p->children[index];
		}

		if (p->isEndingChar == false)
		{
			return; // 不能完全匹配，只是前缀
		}
		else
		{
			// 找到pattern
			p->isEndingChar = false;
			return;
		}
	}

private:
	class TrieNode;
	void destroyTrieNode(TrieNode *node)
	{
		if (node && !node->isEndingChar)
		{
			for (int i = 0; i < 26; ++i)
			{
				destroyTrieNode(node->children[i]);
			}

			delete[] node->children;
		}
	}

private:
	class TrieNode
	{
	public:
		TrieNode(char value = '*') : data(value), isEndingChar(false)
		{
			children = new TrieNode*[26];
			for (int i = 0; i < 26; ++i)
			{
				children[i] = NULL;
			}
		}
	public:
		char data;
		TrieNode **children;
		bool isEndingChar;
	};

private:
	TrieNode *root;
};

int main()
{
	//test 1
	//Trie trie;
	//trie.insert("how");
	//trie.insert("hi");
	//trie.insert("her");
	//trie.insert("hello");
	//trie.insert("so");
	//trie.insert("see");


	//bool bFind = trie.find("hi");
	//bFind = trie.find("he");
	//bFind = trie.find("soo");
	//bFind = trie.find("see");

	//trie.del("soo");
	//trie.del("see");
	//bFind = trie.find("see");

	//test 2
	Trie trie2;
	trie2.insert("hey");
	trie2.insert("he");

	bool bFind2 = trie2.find("he");
	bFind2 = trie2.find("hey");

	return 0;
}

2 相关题目

2.1 实现前缀树

剑指 Offer II 062. 实现前缀树

208. 实现 Trie (前缀树)

class Trie {
private:
    class TrieNode
    {
        public:
        TrieNode(char c='*') : data(c), isEndingChar(false)
        {
            child = new TrieNode*[26];
            for (int i=0;i<26;++i)
            {
                child[i] = NULL;
            }
        }

        public:
        char data;
        bool isEndingChar;
        TrieNode** child;
    };
public:
    /** Initialize your data structure here. */
    Trie() {
        root = new TrieNode('/');
    }
    
    /** Inserts a word into the trie. */
    void insert(string word) {
        TrieNode* cur = root;
        for (int i=0;i<word.length();++i)
        {
            int id = word[i] - 'a';
            if (!cur->child[id])
            {
                cur->child[id] = new TrieNode(word[i]);
            }
            cur = cur->child[id];
        }
        cur->isEndingChar = true;
    }
    
    /** Returns if the word is in the trie. */
    bool search(string word) {
        TrieNode* cur = root;
        for (int i=0;i<word.length();++i)
        {
            int id = word[i] - 'a';
            if (!cur->child[id])
            {
                return false;
            }
            cur = cur->child[id];            
        }

        if (cur->isEndingChar)
            return true;
        else
            return false;
    }
    
    /** Returns if there is any word in the trie that starts with the given prefix. */
    bool startsWith(string prefix) {
        TrieNode* cur = root;
        for (int i=0;i<prefix.length();++i)
        {
            int id = prefix[i] - 'a';
            if (!cur->child[id])
            {
                return false;
            }
            cur = cur->child[id];            
        }

        return true;
    }

private:
    TrieNode* root;    
};

/**
 * 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);
 */

2.2 替换单词

剑指 Offer II 063. 替换单词

648. 单词替换

class Solution {
public:
    string replaceWords(vector<string>& dictionary, string sentence) {
        //创建字典树
        Trie* pTrie = new Trie;
        for (string &word: dictionary) 
        {
            pTrie->insert(word);
        }

        //分割单词
        string newSentence;
        istringstream iss(sentence);
        string word;
        while (iss >> word) 
        {
            pTrie->replace(word);
            if (newSentence.empty())
            {
                newSentence.append(word);
            }
            else
            {
                newSentence.append(1,' ').append(word);
            }
        }
        
        return newSentence;
    }
 
private:
    class Trie {
    public:
        Trie(): root(new TrieNode()) {}

        void insert (string &word) 
        {
            TrieNode* p = root.get();
            for (char &c: word) 
            {
                if (!p->childs.count(c)) 
                {
                    p->childs[c] = new TrieNode();  
                }
                p = p->childs[c];
            }
            p->word = &word;
        }

        void replace (string &word) 
        {
            TrieNode* p = root.get();
            for (char &c: word) 
            {
                //找到了词根，修改word指向词根
                if (p && p->word) 
                {
                    word = *(p->word);
                    break;
                }   
                if (!p->childs.count(c)) 
                {
                    break;
                } 
                p = p->childs[c];                        
            }

        }

    private:
        struct TrieNode 
        {
            TrieNode(): word(nullptr) {};
            ~TrieNode() 
            { 
                for (auto& child: childs) 
                {
                    if (child.second) 
                    { 
                        delete child.second;
                    } 
                }
            }
                
            string *word;
            map<char, TrieNode*> childs;
        };

        std::unique_ptr<TrieNode> root;
    };

};

2.3 神奇的字典

676. 实现一个魔法字典

剑指 Offer II 064. 神奇的字典

class MagicDictionary {
private:
    class Trie {
    private:
        struct TrieNode 
        {
            TrieNode(): isEnding(false) {};
            ~TrieNode() 
            { 
                for (auto& child: childs) 
                {
                    if (child.second) 
                    { 
                        delete child.second;
                    } 
                }
            }
                
            bool isEnding;
            unordered_map<char, TrieNode*> childs;
        };        
    public:
        Trie(): root(new TrieNode()) {}
        void insert (const string& word) 
        {
            TrieNode* cur = root;
            for (auto& c: word) 
            {
                if (!cur->childs.count(c))
                {
                    cur->childs[c] = new TrieNode();  
                }
                cur = cur->childs[c];
            }
            cur->isEnding = true;
        }

        bool search (const string& word) 
        {
            TrieNode* cur = root;
            for (int i=0;i<word.length();++i) 
            {
                char c = word[i];
                if (!cur->childs.count(c))
                {
                    for (auto& child : cur->childs)
                    {
                        if (search(child.second, word.substr(i+1)))
                            return true;
                    }

                    return false;
                }
                else
                {
                    for (auto& child : cur->childs)
                    {
                        if (child.first != c &&　search(child.second, word.substr(i+1)))
                            return true;
                    }                        
                    cur = cur->childs[c];
                }                                      
            }

           return false;
        }

        bool search(TrieNode* child, const string& word)
        {
            TrieNode* cur = child;
            for (auto& c: word) 
            {
                if (!cur->childs.count(c))
                    return false;
                cur = cur->childs[c];                      
            }

            if (cur->isEnding)
                return true;
            else
                return false;
        }

    private:
        TrieNode* root;
    };

private:
    Trie* trie;
public:
    /** Initialize your data structure here. */
    MagicDictionary() {
        trie = new Trie();
    }
    
    void buildDict(vector<string> dictionary) {
        for (auto& str : dictionary)
            trie->insert(str);
    }
    
    bool search(string searchWord) {
        return trie->search(searchWord);
    }  
};

/**
 * Your MagicDictionary object will be instantiated and called as such:
 * MagicDictionary* obj = new MagicDictionary();
 * obj->buildDict(dictionary);
 * bool param_2 = obj->search(searchWord);
 */

2.4 单词的压缩编码

820. 单词的压缩编码

剑指 Offer II 065. 最短的单词编码

class Solution {
private:
    class Trie {
    private:
        struct TrieNode 
        {
            TrieNode(): isEnding(false) {};
            ~TrieNode() 
            { 
                for (auto& child: childs) 
                {
                    if (child.second) 
                    { 
                        delete child.second;
                    } 
                }
            }

            bool isEnding;
            unordered_map<char, TrieNode*> childs;
            unordered_map<string, int> mLen;
        };        
    public:
        Trie(): root(new TrieNode()) {}
        void insert (const string& word) 
        {
            TrieNode* cur = root;
            for (int i=0;i<word.length();++i) 
            {
                char c = word[i];
                if (!cur->childs.count(c))
                {
                    cur->childs[c] = new TrieNode();  
                }
                cur = cur->childs[c];
                if (cur->isEnding)
                {
                    root->mLen.erase(word.substr(0,i+1));
                }
            }
            cur->isEnding = true;
            if (cur->childs.empty())
            {
                root->mLen[word] = word.length();
            }
        }

        bool search(TrieNode* child, const string& word)
        {
            TrieNode* cur = child;
            for (auto& c: word) 
            {
                if (!cur->childs.count(c))
                    return false;
                cur = cur->childs[c];                      
            }

            if (cur->isEnding)
                return true;
            else
                return false;
        }

        int getMaxLen()
        {
            int maxLen = 0;            
            for (auto& item : root->mLen)
            {
                maxLen += item.second;
            }

            return maxLen + root->mLen.size();
        }

    private:
        TrieNode* root;
    };

public:
    int minimumLengthEncoding(vector<string>& words) {
        Trie trie;
        for(auto& str:words)
        {
            reverse(str);
            trie.insert(str);
        }
        
        return trie.getMaxLen();
    }

    void reverse(string& str)
    {
        int i=0, j=str.length()-1;
        while(i<j)
        {
            char c = str[i];
            str[i] = str[j];
            str[j] = c;
            ++i;
            --j;
        }
    }
};

2.5 单词之和

剑指 Offer II 066. 单词之和

677. 键值映射

class MapSum {
private:
    class Trie {
    private:
        struct TrieNode 
        {
            TrieNode(): sum(0), isEnding(false) {};
            ~TrieNode() 
            { 
                for (auto& child: childs) 
                {
                    if (child.second) 
                    { 
                        delete child.second;
                    } 
                }
            }
            int sum;
            bool isEnding;
            unordered_map<char, TrieNode*> childs;
        }; 
    public:
        Trie(): root(new TrieNode()) {}
        void insert (const string& key, int val) 
        {
            int sum = val;
            if (mStr2Val.count(key))
            {
                sum = val - mStr2Val[key];
            }
            
            mStr2Val[key] = val;
            TrieNode* cur = root;
            for (auto& c:key) 
            {
                if (!cur->childs.count(c))
                {
                    cur->childs[c] = new TrieNode();  
                }
                cur = cur->childs[c];
                cur->sum += sum;
            }
            cur->isEnding = true;
        }

        int getSum(const string& key)
        {
            TrieNode* cur = root;
            for (auto& c:key) 
            {
                if (!cur->childs.count(c))
                {
                    return 0;  
                }
                cur = cur->childs[c];
            }

            return cur->sum;
        }

    private:
        TrieNode* root;
        unordered_map<string, int> mStr2Val;
    };

private:
    Trie *trie;
public:
    /** Initialize your data structure here. */
    MapSum() {
        trie = new Trie;
    }
    
    void insert(string key, int val) {
        trie->insert(key, val);
    }
    
    int sum(string prefix) {
        return trie->getSum(prefix);
    }
};

/**
 * Your MapSum object will be instantiated and called as such:
 * MapSum* obj = new MapSum();
 * obj->insert(key,val);
 * int param_2 = obj->sum(prefix);
 */

2.6

2.7

2.8

2.9

2.10

2.11

hclbeloved
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode卡-TrieTree:前缀树
07-06
leetcode卡 TrieTree 前缀树 Leetcode > 探索 > 前缀树卡片 一共5个题（除去之前卡片重复的题）
实现trie（前缀树）
qq_40916628的博客
04-14 182
leetcode 208. 实现 Trie (前缀树) Trie，又称前缀树或字典树，是一棵有根树，其每个节点包含以下字段： 指向子节点的指针数组children。对于本题而言，数组长度为 26，即小写英文字母的数量。此时children[0] 对应小写字母 a，children[1] 对应小写字母 b，…，children[25] 对应小写字母 z。 布尔字段 isEnd，表示该节点是否为字符串的结尾。 需要实现： Trie() 初始化前缀树对象。 void insert(String word
leetcode之Trie树
fuzekun的博客
02-20 167
1.Trie树的介绍 Trie树定义 没错他就是这样的一个树 红色表示是一个单词， 白色表示前缀。 Trie树的应用 Trie树 2.Trie树代码 3.实例 leetcode中208, Trie树的实现 注意：可以理解为边存的是字母而点存的是isWord, 所以是在遍历完所有字母后，再次进行判断是否为单词。 class Trie { private: bool isEnd; Trie *next[26]; public: /** Initialize your da
前缀树/字典树
qq_41984724的博客
11-27 144
Trie 树的结点结构 Trie 树是一个有根的树，其结点具有以下字段： 最多 RR 个指向子结点的链接，其中每个链接对应字母表数据集中的一个字母。 本文中假定 RR 为 26，小写拉丁字母的数量。 布尔字段，以指定节点是对应键的结尾还是只是键前缀。 Trie树应用 Trie (发音为 "try") 或前缀树是一种树数据结构，用于检索字符串数据集中的键。这一高效的数据结构有多种应用： 1. 自动补全 2. 拼写检查 3. IP 路由 (最长前缀匹配) 4. T9 (九宫格) 打字预测 5.
详解字典树原理，代码分析leetcode208. 实现 Trie (前缀树)
weixin_44440311的博客
06-07 471
本文介绍一种能够偶快速查找字符串的树形数据结构-----字典树。介绍其原理，以及通过leetcode208题目这个实例，用数组动手实现一棵字典树，并完成其增、查字符串、查字符串前缀的功能。
leetCode Trie树的使用汇总
qq_30429435的博客
03-25 59
【代码】leetCode Trie树的使用汇总。
【Leetcode】字典树（Trie树）算法
小朱小朱绝不认输的博客
05-16 2575
在Trie树（字典树&前缀树）了解了数据结构构建的方法，这篇文章通过实例来对Trie树算法进行训练。 文章目录208. 实现 Trie (前缀树)1. 题目描述2. 思路分析3. 参考代码820. 单词的压缩编码1. 题目描述2. 思路分析3. 参考代码面试题 17.13. 恢复空格1. 题目描述2. 思路分析3. 参考代码211. 添加与搜索单词 - 数据结构设计1. 题目描述2. 思路分析3. 参考代码676. 实现一个魔法字典1. 题目描述2. 思路分析3. 参考代码 简单再回顾一下Trie树
LeetCode 实现Trie(前缀树)
codebloom的博客
04-12 129
题目描述： Trie（发音类似 “try”）或者说 前缀树 是一种树形数据结构，用于高效地存储和检索字符串数据集中的键。这一数据结构有相当多的应用情景，例如自动补完和拼写检查。 请你实现 Trie 类： Trie() 初始化前缀树对象。 void insert(String word) 向前缀树中插入字符串 word 。 boolean search(String word) 如果字符串 word 在前缀树中，返回 true（即，在检索之前已经插入）；否则，返回 false 。 boolean starts
208_实现Trie(前缀树)
weixin_41529389的博客
01-04 149
""" 实现一个 Trie (前缀树)，包含 insert, search, 和 startsWith 这三个操作。 示例: Trie trie = new Trie(); trie.insert("apple"); trie.search("apple"); // 返回 true trie.search("app"); // 返回 false trie.startsWith("ap...
LeetCode 208 实现Trie(前缀树) HERODING的LeetCode之路
HERODING23的博客
04-14 143
Trie（发音类似 “try”）或者说 前缀树 是一种树形数据结构，用于高效地存储和检索字符串数据集中的键。这一数据结构有相当多的应用情景，例如自动补完和拼写检查。 请你实现 Trie 类： Trie() 初始化前缀树对象。 void insert(String word) 向前缀树中插入字符串 word 。 boolean search(String word) 如果字符串 word 在前缀树中，返回 true（即，在检索之前已经插入）；否则，返回 false 。 boolean startsWith(S
[LeetCode]Implement Trie(Prefix Tree)，解题报告
小一的专栏
05-15 6139
目录目录 概述 Trie树基本实现 定义Trie树节点 添加操作 查询word是否在Trie树中 AC完整代码概述Trie树，又称为字典树、单词查找树或者前缀树，是一种用于快速检索的多叉数结构。例如，英文字母的字典树是26叉数，数字的字典树是10叉树。 Trie树的基本性质有三点，归纳为： 根节点不包含字符，根节点外每一个节点都只包含一个字符。 从根节点到某一节点，路径上经过的字符连接起来，为该节
leetcode不会-implement-trie:树实现
06-30
leetcode 不会树实现 使用插入、搜索和startsWith 方法实现一个trie。 Example: Trie trie = new Trie(); trie.insert("apple"); trie.search("apple"); // returns true trie.search("app"); // returns false trie...
leetcode走楼梯-Leetcode-Patterns-Cpp:Leetcode-Patterns-Cpp
07-01
Trie（前缀树） 如果概念已知，则直截了当。 目标金额 基本 dfs 被接受，记忆化有不错的加速。 最优解使用子集和，应该研究。 生成括号 对于 n > 0，总是最左边有一个左括号。 如果最左边括号内的表达式及其补码有 i...
leetcode安卓-TRIE-Algorithm:用各种语言实现的Trie及其性能测试
06-30
leetcode安卓TRIE-算法 派生自Retrie val 用各种语言实现的 Trie 及其性能测试 博客和 Stackoverflow 图书馆 安卓 Java 安卓 Java 安卓 我的现场演示实现 单词列表资源
LeetCode-Python-820. 单词的压缩编码（字典树 Trie Tree）
12-21
给定一个单词列表，我们将这个列表编码成一个索引字符串 S 与一个索引列表 A。 例如，如果这个列表是 [“time”, “me”, “bell”]，我们就可以将其表示为 S = “time#bell#” 和 indexes = [0, 2, 5]。...
LeetCode---394周赛
V_zjs的博客
04-27 497
LeetCode---394周赛---模拟+位运算优化+状态转移+动规+Dijkstra算法
算法训练营第十一天 | LeetCode 20 有效的括号、LeetCode 1047 删除字符串中的所有相邻重复项
qq_63149342的博客
04-27 118
注意用的是字符串数组作为输入，而我们要用int型进行计算，这时候就要用到一个string转int类型的库函数stoi函数，aoti是字符数组转int类型。一个是最后循环结束后要判断栈内存是否为空，一个是出栈时要判断栈是否为空，总的来说是考验对于栈内存空间的掌控吧。这一题考栈的性质，相邻字符用未进栈的元素和进栈的元素进行模拟即可，相同且栈不为空即出栈，否则进栈，之后将栈内元素全部导入一个字符串，还要注意要写一个反转函数翻转下即可。LeetCode 1047 删除字符串中的所有相邻重复项。
力扣数据库题库学习（4.28日）--1587. 银行账户概要 II
最新发布
Jesse_Kyrie的博客
04-28 175
对于力扣题1587. 银行账户概要 II的解答，提供解题思路与解题方法，知识点为:1. GROUP BY 2. SUM 3. LEFT JOIN 4. HAVING
力扣每日一题-查询网格图中每一列的宽度-2024.4.27
孤舟一叶～的博客
04-27 358
双层for循环遍历整个矩阵容易想到，只要能想到使用整数转字符串的技巧（“” + 字符串），即可完成题目。
idea leetcode-edito乱码
09-01
LeetCode-Editor是一种在线编码工具，它提供了一个用户友好的界面编写和运行代码。在使用LeetCode-Editor时，有时候会出现乱码的问题。 乱码的原因可能是由于编码格式不兼容或者编码错误导致的。在这种情况下，我们...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值