C++ 树进阶系列之深度剖析字典（trie）树

最新推荐文章于 2024-06-24 17:24:49 发布
最新推荐文章于 2024-06-24 17:24:49 发布
阅读量1k 收藏 12
点赞数 2
文章标签： c++ 数据结构 链表 字典树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/y6123236/article/details/129683289
版权

1. 前文

本文和大家一起聊聊字典树，从字典二字可知，于功能而言，字典树是类似于英汉字典的一棵信息树。字典树有 2 大特点：

  • 有容乃大。能存储大量的数据信息。
  • 提供有基于关键字的查询、检索机制。

常用字典树存储字符串（单词）信息，使用字典树能方便实现字符串的存储、查询、统计、排序……一系列操作。

2. 字典树特点

字典树是树结构的典型应用，如下图所示，为一棵字典树。字典树的叶节点起标志性作用，标记字符串的结束，类似于C++字符串的结束符号\0。

1.png

通过对结构的观察，可以大致了解字典树的几个特点：

  • 字典树不是二叉树，字典树的每一个节点可以有多个子节点，除根节点外每个节点存储一个字符信息(常用于字符信息存储，但不仅限于字符信息)。
  • 顺着根节点向子节点连接，可以找到一个字符串信息。正因为这个特性，字典树如其名，可存储大量的单词。如从根节点开始，找到它的第一个子节点a，然后找到a的子节点c，再顺着 c找到e。这样就能得到子符串ace。
  • 具有公共前缀的字符串不需要重复存储，公用共同的祖先，如ace和act的公共祖先节点是ac。这也是字典树的一大特点，相比较其它的存储方案，具有高度的空间利用率。

3. 字典树的物理存储

字典树常用的API有插入和查询，其它可根据应用场景的需要进行扩展。

字典树的物理实现可以使用矩阵和链式存储 2 种方案，本文分别探讨这 2 种方案的实现过程。

3.1 链式存储

为了简化操作，实现过程中使用了STL的vector容器存储任一节点的子节点，当然，也可以使用带有头节点的链表。

3.1.1 结构类型

节点类型： 存储字典树的节点信息。

#include <iostream>
#include <vector>
using namespace std;
/*
*字典树节点
*/
struct TrieNode {
	//节点对应字符
	char data;
	//所有子节点指针
	vector<TrieNode*> childs;
    TrieNode(){
		this->data='#';
	} 
};

字典类： 维护字典的常用API，此处先提供基本的API，后面根据需要再扩展。

/*
*字典树类
*/
class Trie {
	private:
		//根节点
		TrieNode* root;
		//字典树上所有字符串(单词)
		vector<string> words;
	public:
		/*
		*构建函数
		*/
		Trie() {
			//初始化节结点
			this->root=new TrieNode();
		}
		/*
		*返回节结点
		*/
		TrieNode* getRoot() {
			return this->root;
		}
		/*
		* 查询节点是否包括值为 ch 的子节点
		*/
		TrieNode* findChild(TrieNode* parent,char ch);
		/*
		*插入新的单词（字符串）
		*/
		void insert(string word);
		/*
		*查询字典树是否存在指定的字符串（单词）
		*/
		TrieNode* search(string word);
		/*
		* 查询字典树上所有字符串（单词）
		*/
		void getAllWords(TrieNode *node,string word);
		/*
		*显示字典树上的所有单词
		*/
		void showAllWords()
}
3.1.2 常规 API
3.1.2.1 insert函数

功能描述： 提供添加字符串（单词）的功能，是构建字典树的第一重要环节。

**实现流程：**现以添加abc字符串为例，讲解添加函数的实现过程。

  • 首先构建根节点。根节点不需要存储具体的数据信息。

2.png

  • 分解字符串abc，先读入字符a，以根节点为当前节点，查询当前节点是否存在值为a的子节点。

3.png

  • 因字典树刚创建，此子节点不存在，则为节结点新建值为a的子节点，并且当前节点指针指向新建的节点。

4.png

  • 继续从字符串中分割出字符b，检查当前节点是否存在值为b的子节点。没有则为当前节点创建值为b的新节点，重设当前节点的指针为新建节点。
    5.png

  • 同理，分割出c，因当前节点不存在值为c的子节点，为当前节点构建新节点。且重设当前节点的指针。

6.png

  • 当字符串分割完毕后，最后添加值为#的叶节点作为结束标志符。

7.png

  • 在现有字典树上继续添加abd字符串（单词）时，当前节点需要重置为根结点。分割abd字符串时，因为值为a和b的节点已经存在，则仅让当前节点向下滑动。

8.png

  • 分割出d字符，因当前节点不存在值为d的子节点，新建值为d的子节点。字符串分割完毕，为d节点添加结束子节点。如下图所示。

9.png

编码实现：

实现辅助函数findChild：

/*
* 查询节点是否包括值为 ch 的子节点
*/
TrieNode* Trie::findChild(TrieNode* parent,char ch){
    //获取当前节点的所有子节点
    vector<TrieNode*> childs= parent->childs;
    //遍历查询
    for(int i=0; i<childs.size(); i++) {
        if( childs[i]->data==ch  ) {
            //存在
            return childs[i];
        }
    }
    //不存在
    return NULL;
}

实现insert函数：

/*
* 插入新的单词（字符串）
* 参数：word 需要添加的字符串
*/
void Trie::insert(string word) {
    //从根节点开始
    TrieNode* currentNode=this->root;
    //分割字符串
    for(int i=0; i<word.size(); i++  ) {
        //查询子节点是否存在
        TrieNode* childNode= Trie::findChild(currentNode,word[i]);
        if(childNode==NULL  ) {
            //子节点不存在，构建新节点
            TrieNode* newNode=new TrieNode();
            newNode->data=word[i];
            //成为当前节点的子节点
            currentNode->childs.push_back(newNode);
            //重设当前节点
            currentNode= newNode;
        } else {
            //节点存在
            currentNode= childNode;
        }
    }
    //分割完毕，添加标志性节点
    TrieNode* flagNode=new TrieNode();
    currentNode->childs.push_back(flagNode);
}

测试插入函数：

int main(int argc, char** argv) {
	Trie* trie=new Trie();
	trie->insert("abc");
	trie->insert("abd");
	TrieNode* root=trie->getRoot();
	cout<<"根节点的子节点："<<root->childs[0]->data<<endl;
	cout<<"根节点的子节点的子节点："<<root->childs[0]->childs[0]->data<<endl;
	cout<<"节点的子节点的子节点的子节点:"<<root->childs[0]->childs[0]->childs[0]->data<<endl;
	cout<<"节点的子节点的子节点的子节点:"<<root->childs[0]->childs[0]->childs[1]->data<<endl;
	return 0;
}

输出结果：

10.png

3.1.2.2 search函数

功能描述： 查询给定的字符串（单词）是否存在于字典树中。

实现流程： 查询和插入流程相似。如果检查到存在与分割出来的字符值相等的子节点便继续向下查询，否则，认为查询失败。

不要求一定的是完整字符串（单词），仅是前缀也可以。

如下图所示，虽然字典树中不存在ab字符串（单词），因为存在ab前缀，也认为是存在的。

11.png

编码实现：

/*
* 查询字典树是否存在指定的字符串（单词）
*/
TrieNode* Trie::search(string word) {
    //从节结点开始
    TrieNode* currentNode=this->root;
    //分割需要查询的字符串
    for(int i=0; i<word.size(); i++) {
        //子节点是否存在
        TrieNode* childNode= Trie::findChild(currentNode,word[i]);
        if(childNode!=NULL) {
            //继续查询
            currentNode=childNode;
        } else {
            //不存在
            return NULL;
        }
    }
    //查询成功，只要字符串和字典树上的字符一一对应便可
    return currentNode;
}

测试查询：

int main(int argc, char** argv) {
	Trie* trie=new Trie();
	trie->insert("abc");
	trie->insert("abd");
	TrieNode* root=trie->getRoot();
	TrieNode* node= trie->search("ab");
	if(node!=NULL){
		cout<<"字典树中存在 ab"<<endl; 
	}else{
		cout<<"字典树上不存 ab"<<endl;
	}
	return 0;
}

输出结果：

12.png

3.1.2.3 getAllWords函数

功能描述： 返回字典树上的所有字符串（单词）。

实现流程： 对于整棵树的搜索常用的方案有深度和广度搜索。针对此需求使用深度搜索便能查询出树上的所有单词。

13.png

编码实现：

实现辅助函数 showAllWords：显示字典树上的所有单词。

/*
*显示所有单词
*/
void showAllWords() {
    cout<<"字典树上的所有单词:"<<endl; 
    for(int i=0; i<this->words.size(); i++) {
        cout<<this->words[i]<<endl;
    }
}

实现getAllWords函数：

/*
* 显示字典树上所有字符串
*/
void Trie::getAllWords(TrieNode *node,string word) {
    //当前节点
    TrieNode* currentNode=node;
    //当前节点的子节点
    vector<TrieNode*> childs=currentNode->childs;
    for(int i=0; i<childs.size(); i++) {
        if(childs[i]->data=='#') {
            //如果节点值为结束符号，则获取到了完整单词
            this->words.push_back(word);
        } else {
            //否则，继续递归
            string word_=word;
            word_.append( {childs[i]->data} );
            getAllWords(childs[i], word_ );
        }
    }
}

测试代码：

int main(int argc, char** argv) {
	Trie* trie=new Trie();
	trie->insert("abc");
	trie->insert("abd");
	TrieNode* root=trie->getRoot();
	trie->getAllWords(root,"");
	trie->showAllWords();
	return 0;
}

输出结果：

14.png

3.2 矩阵存储

使用矩阵存储树节点之间的关系也是一种常见方案。

基本存储思想：

  • 对每一个节点进行编号。

  • 以父节点的编号为矩阵的行号，子节点的编号为列号，行与列对应的单元格中存储节点的关系描述（或值、权重）。

15.png

在存储字典树信息时，对上述的存储方案可以稍加改进一下。

  • 如先确定根节点的编号为0，子节点a在矩阵中的列号由其对应的ASCII码决定，当然，会对其范围缩小。

    对应单元格中存储字符出现的顺序编号，并以此编号为此结点的唯一标志符号（类似于主键）。

    这个编号与字符添加顺序有关，与字符本身无关。如下图所示：

16.png

  • 字符b是字符a的子节点。添加过程如下图所示。

17.png

  • 继续完成其它节点关系的存储。

18.png

上述存储的优点：

  • 可以把矩阵的列数限制在 26 之内。
  • 查询任一节点的子节点时，可以根据字符本身所携带信息找到其存储位置。如果b节点下还有字符w的子节点，便能轻易知道其存储位置是 [2]['w'-'a']并能获取w节点的编号。

编码实现：

与前文的链式存储相毕较，仅是改变了存储方式，逻辑是没有发生任何变化。

#include <iostream>
#include <vector>
using namespace std;
/*
* 字典树类
*/
class Trie {
	private:
		/*
		* 矩阵：存储结点之间的关系
		* 1、矩阵的行数由结点数量决定， 简化问题，此处设置为 100
		* 2、矩阵的列数由字符数量决定
		*/
		int matrix[100][26];
		//所有节点由内部统一编号
		int number;
		//字符串的节束标志
		char endFlag[100];
		//存储字典树上的所有单词
		vector<string> allWords;
	public:
        /*
        * 初始化
        */
		Trie() {
			this->number=0;
			for(int i=0; i<100; i++)
				for(int j=0; j<26; j++)
					matrix[i][j]=0;
		}
		/*
		* 插入函数
		*/
		int insert(string word) {
			//当前节点指向节结点
			int current=0;
			//遍历字符串
			for(int i=0; i<word.size(); i++) {
				//检查当前节点下是否存在值为 word[i] 的子节点
				if( matrix[current][ word[i]-'a' ]==0 ) {
					//不存在
					matrix[current][ word[i]-'a' ]=++this->number;
				}
				//重设当前节点
				current=matrix[current][ word[i]-'a' ];
			}
			//添加结束标志
			endFlag[current]='#';
		}

		/*
		*查询指定的字符串是否存在字典树中
		*/
		int search(string word) {
			//从根节点开始
			int current=0;
			//遍历字符串
			for(int i=0; i<word.size(); i++) {
				if( matrix[current][ word[i]-'a' ]==0 ) {
					//没找到
					return -1;
				}
				//继续
				current= matrix[current][ word[i]-'a' ];
			}
			return current;
		}

		/*
		* 使用深度搜索算法获取树上的所有单词
		*/
		void getAllWords(int parent,string word) {
			int current=parent;
			//查询所有子节点
			for(int i=0; i<26; i++) {
				if(matrix[current][i]!=0  ) {
					if( endFlag[matrix[current][i]]=='#'  ) {
                         //注意此处需要添加一下
						word.append( {  char(i+'a')  } );
						this->allWords.push_back(word);
                          //恢复
						word.pop_back();
					} else {
						string word_=word;
						word_.append( {  char(i+'a')  } );
                          //递归调用
						getAllWords( matrix[current][i], word_);
					}
				}
			}
		}
		/*
		*显示字典树上的所有单词
		*/
		void showAllWords() {
			cout<<"字典树上的所有单词:"<<endl;
			for(int i=0; i<this->allWords.size(); i++ )
				cout<<this->allWords[i]<<endl;
        }
};
//测试
int main() {
	Trie*  trie=new Trie();
	trie->insert("abc");
	trie->insert("abd");
	int res= trie->search("ab");
	cout<<res<<endl;
	trie->getAllWords(0,"");
	trie->showAllWords();
	return 0;
}

输出结果：

19.png

使用数组存储的优点：

  • 在查询所有单词时，会自动对其按字典进行排序。
  • 实现起来较直观，易理解。

4. 字典树的应用

至此，想必对字典树有了较好的理解，下文再提供 2 个案例 ，深入体会字典树的神奇之处。

4.1 自动补全

所谓自动补全：指当用户输入单词前缀，则会显示所有与此前缀有关联的单词。此功能在关键字搜索应用中经常可以看到。

如果字典树中存在单词集["cat","caton","cater","this"]，当用户输入cat时，则自动显示所有以cat为前缀的单词：caton、cater。

实现原理：

  • 在字典树中查找前缀是否存在。
  • 如果存在，以此前缀最后一个字符的节点为当前节点进行深度搜索。

20.png

编码实现：

在前文的矩阵实现方案中添加如下函数。

class Trie{
    //省略…… 
    /*
    *自动补全函数
    */
    void autoComplete(string prefix) {
        //查询前缀字符串在字典树中是存在
        int nodeId= this->search(prefix);
        if(nodeId==-1) {
            return;
        }
        //存在，则从此节点开始进行深度搜索
        this->getAllWords(nodeId,prefix);
    }
    //省略……
}
//测试
int main() {
	Trie*  trie=new Trie();
	trie->insert("cat");
	trie->insert("caton");
	trie->insert("cater");
	trie->insert("this");
	trie->autoComplete("cat");
	trie->showAllWords();
	return 0;
}

输出结果：

21.png

4.2 求 2 个字符串的最长公共前缀

所谓字符串的公共前缀指字符串前面相同的部分。如caton和cater的公共前缀是cat。与自动补全功能是相逆的操作。

基本思想：

  • 使用字典树存储所有字符串。
  • 两个字符串的最长公共前缀的长度即他们所在的节点的公共祖先个数，于是，问题就转化为求公共祖先问题。

在树中求解节点的公共祖先问题可以有多种方案，本文侧重于字典树的理解，仅提供下面的穷举算法。其它方案可以自行查阅相关书籍。

/*
* 穷举算法求解 2 个字符串的求公共前缀
*/
string getMaxPrefix(string word,string word_) {
    string prefix="";
    //指向根结点
    int current=0;
    int idx=0;
    //最多查询结点数
    int len=word.size()>word_.size()?word_.size():word.size();
    while(idx<len) {
        int ok=false;
        //查询当前结点的子结点
        for(int i=0; i<26; i++) {
            if(matrix[current][i]==0)continue;
            //存在子结点，且为同一个结点
            if( matrix[current][ word[idx]-'a' ]!=0 &&  matrix[current][ word[idx]-'a' ]==matrix[current][ word_[idx]-'a' ]  ) {
                ok=true;
                prefix.append({ word[idx] });
                current=matrix[current][ word[idx]-'a' ];
                break;
            }
        }
        if(!ok)
            break;
        idx++;
    }
    return prefix;
}

测试：

int main() {
	Trie*  trie=new Trie();
	trie->insert("cat");
	trie->insert("caten");
	trie->insert("cater");
	trie->insert("this");
	string prefix=trie->getMaxPrefix("caten","cater");
	cout<<"公共前缀："<<prefix;
	return 0;
}

输出结果：

22.png

5. 总结

本文介绍了字典树的逻辑结构，并且使用链式和矩阵2种方案实现了字典的物理存储。并且通过 2个具有代表性的案例让大家更深入理解字典树的实际应用。

一枚大果壳
关注
  • 2
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
C++ 字典树详解(含例题)
jerry20183的博客
02-03 4326
C++ 字典树详解(含例题) 字典树的定义 顾名思义，就是一个像字典一样的树，谢谢观看 我们想要熟练的运用字典树，首先肯定要知道什么样的结构才会被称之为字典树吧。 字典树是一种树形结构，典型应用是用于统计，排序和保存大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：利用字符串的公共前缀来减少查询时间，最大限度地减少无谓的字符串比较———百度百科 从上面的百度百科的一段定义中，我们知道了字典树是：利用字符串的公共前缀来减少复杂度；用于统计，排序和保存大量字符串的数据结构
数据结构——线性表：字典（C++）
Hodge_Z的博客
12-25 3722
内容概要： 字典的相关概念 注意事项 简单的字典实现 一、字典的相关概念 字典（dictionary）是在数据库中具有存储、查询和删除记录的功能的线性表。 数据库中的记录一般是靠关键码（key）描述的，类似人们的ID号码。 关键码应当具有可比性（comparable）。 二、注意事项 由于关键码类型非常多，不能编写出通用的字典。 关键码不是记录的类的基本属性，也不是类中任意的域，它...
acm 算法 字典树模板
05-29
acm字典树模板！acm字典树模板！acm字典树模板！acm字典树模板！
字典树（Trie树）详解
Brilliant_Sky的博客
04-16 1050
字典树（Trie树）详解&例题
c++字典
最新发布
qq_44691564的博客
06-24 308
如果更关注性能且不需要有序性，可以选择std::unordered_map。在C++中，“字典”通常指的是std::map或std::unordered_map，它们是标准库中提供的关联容器，用于存储键值对。std::unordered_map：键值对无序，但查找、插入和删除速度更快，适用于不需要顺序的场景。例如，如果你需要按字母顺序遍历元素。使用 std::map std::map 是一种有序的关联容器，键值对按键排序。使用 std::unordered_map std::unordered_map。
C++(数据结构与算法):27---字典介绍
董哥的黑板报
12-08 7180
一、字典 字典（dictionary）是由一些形如(k,v)的数对所组成的集合，其中： k：是关键字 v：是与关键字k对应的值 任意两个数对，其关键字都不等 多重字典：两个或更多的数对可以具有相同的关键字 有关字典的操作如下： 确定字典是否为空 确定字典有多少数对 寻找一个指定了关键字的数对 插入一个数对 删除一个指定了关键字的数对 二、字典的抽象数据类型...
数据结构与算法C++描述（9）---字典
Hello~~~
10-25 3874
1.字典的概念字典是一些节点的集合，每个节点包含数据域和key（键值）域。字典可以通过公式化描述或链表描述的方式创建。本文将通过链表描述的方式创建字典，字典的键值是依次递增的，并对字典进行如下操作： 字典的删除； 添加一个字典元素； 判断字典是否为空； 搜索键值为k的元素值； 获取字典中的元素个数； 在键值为k的节点中插入元素x，允许键值k已存在； 在键值为k的节点中插入元素x,不允许键值k存在，即
C++容器——字典（unordered_map）
shouhu010的博客
03-30 3135
c++ 容器 unordered_map 定义 初始化 基本操作
C++容器——字典（map）
shouhu010的博客
03-22 2393
c++容器map 初始化 元素查找 修改 迭代器
字典树（Trie树） C++实现
A man can be destroyed, but not defeated.
07-31 555
代码如下： //插入、删除、查询、遍历四种操作 #include #define rep(i,a,n) for(int (i) = a; (i)<=(n); (i)++) #define ms(a,b) memset((a),(b),sizeof((a))) using namespace std; typedef long long LL; const double eps = 1e-6; c
C++前缀树trie的实现
12-25
C++实现的前缀树trie数据结构
c++字典列表
08-12
自己写一个map + list 的c++数据结构。双迭代器，里面有有个简单例子。
详解字典树Trie结构及其Python代码实现
09-21
字典树，也称为Trie，是一种特殊的树形数据结构，主要用于快速查找和统计具有公共前缀的字符串。这种数据结构在处理大量字符串时特别有用，例如在搜索引擎的文本词频统计、搜索建议和拼写检查等场景中。Trie的主要...
Trie树(字典树)的介绍及Java实现
08-31
Trie树，也被称为字典树或前缀树，是一种数据结构，主要用于高效地存储和检索字符串集合中的数据。在Trie树中，每个节点代表一个字符串的前缀，从根节点到某个节点的路径上的字符序列构成了该节点对应的字符串。这种...
Trie树_字典树(字符串排序)简介及实现
10-26
有时，我们会碰到对字符串的排序，若采用一些经典的排序算法，则时间复杂度一般为O(n*lgn)，但若采用Trie树，则时间复杂度仅为O(n)
PHP字典树(Trie树)定义与实现方法示例
10-19
字典树，又称为Trie树或前缀树，是一种高效的数据结构，主要用于存储和检索具有公共前缀的字符串。这种数据结构能够大大减少字符串比较的次数，提高查询效率，尤其在处理大量字符串时效果显著。在搜索引擎系统中，...
11.1 C++ STL 应用字典与列表
热门推荐
CSDN
08-17 1万+
C++ STL 标准模板库提供了丰富的容器和算法，这些模板可以灵活组合使用，以满足不同场景下的需求。本章内容将对前面学习的知识进行总结，并重点讲解如何灵活使用STL中的vector和map容器，以及如何结合不同的算法进行组合。 通过灵活组合使用这些容器和算法，能够满足不同场景下的需求，实现高效的数据处理和操作。STL的设计思想是将数据结构和算法进行分离，使得开发者能够更加专注于解决问题，提高了代码的可读性和可维护性。因此，掌握STL的使用技巧对于C++程序员来说是非常重要的。
C++ 字典 map详解
cxu123321的博客
11-03 4647
C++ 字典 map详解 2019-01-18 23:32:08lh_lyh阅读数 1123更多 文章目录 容器重要属性 操作 迭代器 1. begin 指向起始 2. end 指向末尾 3. rbegin 指向倒序起始（即末尾） 4. rend 指向倒序末尾（即起始） 大小 1. empty 判断容器是否为空 2. size 返回容器...
C++实现字典数据结构
weixin_45520588的博客
09-23 8240
本文使用C++构建了一个字典数据结构，未使用STL，实现了一个学生成绩录入系统，进而实现了字典数据对象的如下功能： 新建一个字典； 检查字典非空； 得到字典的数据长度； 插入一个数对； 按学生姓名删除对应的字典数据； 按分数查找所有符合的学生姓名； 按姓名查找对应成绩； 遍历输出链表； 该程序使用了pair容器，整个程序基于线性表数据结构（链表描述）。由3个文件构成，头文件定义了字典类，函数定...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

一枚大果壳

码文不易，晚上熬夜需要点咖啡钱

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

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

打赏作者

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

抵扣说明：

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

余额充值