Trie树的常见应用大总结（面试+附代码实现）

最新推荐文章于 2024-03-16 00:20:14 发布
最新推荐文章于 2024-03-16 00:20:14 发布
阅读量1.1w 收藏 37
点赞数 7
分类专栏： 数据结构和算法 文章标签： c++ trie树 面试 海量数据 代码实现
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nk_test/article/details/47836119
版权
（一）Trie的简介
Trie树，又称字典树，单词查找树或者前缀树，是一种用于快速检索的多叉树结构，如英文字母的字典树是一个26叉树，数字的字典树是一个10叉树。他的核心思想是空间换时间，空间消耗大但是插入和查询有着很优秀的时间复杂度。
（二）Trie的定义

Trie树的键不是直接保存在节点中，而是由节点在树中的位置决定。一个节点的所有子孙都有相同的前缀（prefix）,从根节点到当前结点的路径上的所有字母组成当前位置的字符串，结点可以保存当前字符串、出现次数、指针数组(指向子树)以及是否是结尾标志等等。

typedef struct Trie_Node
{
   	char count[15];      //单词前缀出现的次数 
   	struct Trie_Node* next[MAXN];    //指向各个子树的指针 
	bool exist;    //标记结点处是否构成单词 
}Trie;

Trie树可以利用字符串的公共前缀来节约存储空间，如下图所示：


它有3个基本性质：
(1) 根节点不包含字符，除根节点外每一个节点都只包含一个字符。
(2) 从根节点到某一节点，路径上经过的字符连接起来，为该节点对应的字符串。
(3) 每个节点的所有子节点包含的字符都不相同。
（三）Trie树的基本操作
（1）插入操作
按下标索引逐个插入字母，若当前字母存在则继续下一个，否则new出当前字母的结点，所以插入的时间复杂度只和字符串的长度n有关，为O(n)。

void Insert(Trie *root, char* s,char *add)
{
	Trie *p=root;
	while(*s!='\0')
	{
		if(p->next[*s-'a']==NULL)
		{
			p->next[*s-'a']=createNode();
		}
		p=p->next[*s-'a'];
       // p->count=add;
        ++s; 
	}
	p->exist=true; 
    strcpy(p->count,add);
}
（2）查询操作
和插入操作相仿，若查询途中某一个结点并不存在，则直接就return返回。否则继续下去，当字符串结束时，trie树上也有结束标志，那么证明此字符串存在，return true； 

int Search(Trie* root,const char* s)
{
	Trie *p=root;
	while(*s!='\0')
	{
		p=p->next[*s-'a'];
		if(p==NULL)
		return 0;
		++s;
	}
	return p->count;
}

（3）删除操作

一般来说，对Trie单个结点的删除操作不常见，所以我在这里也只提供递归删除整个树的操作

void del(Trie *root)
{
	for(int i=0;i<MAXN;i++)
	{
		if(root->next[i]!=NULL)
		{
		   del(root->next[i]);	
		}
	}
//	free(root);   
   delete root;
}

（4）遍历操作

如果我们想要将trie中的字符串排序输出，直接先序遍历即可。

void Print(Trie *root)
{
	Trie *p=root;
	if(p->exist)
	cout<<p->name<<": "<<p->count<<endl;
	for(int i=0;i<26;i++)
	{
		if(p->next[i]!=NULL){
			Print(p->next[i]);
		}
	} 
}
（四）Trie树的具体应用
（1）统计前缀出现的次数
这是Trie最基本的应用，每个结点的字母使用count记录出现的次数即可。
这里提供一道题目，hdu 1251供大家练习。 

//hdu 1251   统计前缀出现次数 
#include <cstdio>
#include <iostream>
#include <string>
#include <cstring>
using namespace std;
const int MAXN=26;
typedef struct Trie_Node
{
   	int count;      //单词前缀出现的次数 
   	struct Trie_Node* next[MAXN];    //指向各个子树的指针 
	bool exist;    //标记结点处是否构成单词 
}Trie;
Trie* createNode()
{
	//Trie* p =(Trie*)malloc(sizeof(Trie));
	Trie *p=new Trie;
	p->count=0;
	p->exist=false;
	memset(p->next,0,sizeof(p->next));
	return p;
}
void Insert(Trie *root, const char* s)
{
	Trie *p=root;
	while(*s!='\0')
	{
		if(p->next[*s-'a']==NULL)
		{
			p->next[*s-'a']=createNode();
		}
		p=p->next[*s-'a'];
        p->count+=1;
        ++s; 
	}
	p->exist=true; 
}

int Search(Trie* root,const char* s)
{
	Trie *p=root;
	while(*s!='\0')
	{
		p=p->next[*s-'a'];
		if(p==NULL)
		return 0;
		++s;
	}
	return p->count;
}

void del(Trie *root)
{
	for(int i=0;i<MAXN;i++)
	{
		if(root->next[i]!=NULL)
		{
		   del(root->next[i]);	
		}
	}
//	free(root);   
   delete root;
}
int main()
{
	char s[15];
	bool flag=false;
	Trie* root=createNode();
	while(gets(s))
	{
		if(flag)
		{
		   int ans=Search(root,s);
		   printf("%d\n",ans);	
		}	
		else
		{
			if(strlen(s)!=0)
			Insert(root,s);
		}
		if(strlen(s)==0)
		flag=true;	
	}
	del(root);
	return 0;
}
（2）翻译（密码，明文）
给定一组字符串s，k我们输入k则需要翻译成s，也就是说两者是映射关系。接下来我们给出一段话，让你翻译出正常的文章。用map固然简便，但是Trie的效率更加高。只需要在k的结尾结点出记录下s即可。
这里也提供一道题目，hdu 1075。(被注释的是我原来的程序，wa了，有大神看出来麻烦告诉我一下，谢谢)。 

/*
//hdu 1075映射 
#include <cstdio>
#include <iostream>
#include <string>
#include <cstring>
#include <stdlib.h>
using namespace std;
const int MAXN=26;
typedef struct Trie_Node
{
   	char count[15];      //单词前缀出现的次数 
   	struct Trie_Node* next[MAXN];    //指向各个子树的指针 
	bool exist;    //标记结点处是否构成单词 
}Trie;
Trie* createNode()
{
	Trie* p =(Trie*)malloc(sizeof(Trie));
	p->exist=false;
	memset(p->next,0,sizeof(p->next));
	return p;
}
void Insert(Trie *root, char* s,char *add)
{
	Trie *p=root;
	while(*s!='\0')
	{
		if(p->next[*s-'a']==NULL)
		{
			p->next[*s-'a']=createNode();
		}
		p=p->next[*s-'a'];
       // p->count=add;
        ++s; 
	}
	p->exist=true; 
    strcpy(p->count,add);
}



void Search(Trie* root, const char* s)
{
	Trie *p=root;
	while(*s!='\0')
	{
		if(p->next[*s-'a']==NULL)
		{  
		    printf("%s",s);
		    return ;
		}
	
		p=p->next[*s-'a'];
	    ++s;
	}
	if(p->exist)
    printf("%s",p->count);
    else
    printf("%s",s);
}

void del(Trie *root)
{
	for(int i=0;i<MAXN;i++)
	{
		if(root->next[i]!=NULL)
		{
		   del(root->next[i]);	
		}
	}
	free(root);   
}
int main()
{
	char text[3013],from[15],to[15];
	Trie* root=createNode();
	scanf("%s",from);
    while(scanf("%s",from),strcmp(from,"END"))
    {
    	scanf("%s",to);
    	Insert(root,to,from);
    }
    scanf("%s",from);
    getchar();
    while(gets(text),strcmp(text,"END"))
    {
    	int len=strlen(text);
    	for(int i=0;i<len;i++)
    	{
	    	if(islower(text[i]))
	    	{
	    		int j=0;
	    		char temp[15];
	    		memset(temp,'\0',sizeof(temp));
	    		while(islower(text[i]))
	    		temp[j++]=text[i++];
	    		Search(root,temp);
	    	 
	    	}
	    	if(!islower(text[i]))
	    	printf("%c",text[i]);
	    }
	    printf("\n");
    }
	return 0;
}
*/

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<string>

using namespace std;

struct node{
    char dic[15];
    node * next[26];
    bool flag;
}*root;

node *build()
{
    node *p=(node *)malloc(sizeof(node));
    for(int i=0;i<26;i++)
        p->next[i]=NULL;
    p->flag=false;
    return p;
}

void insert(char *earth,char *mars)
{
    int len=strlen(mars);
    node *p;
    p=root;
    for(int i=0;i<len;i++)
    {
        if(p->next[mars[i]-'a']==NULL)
            p->next[mars[i]-'a']=build();
        p=p->next[mars[i]-'a'];
    }
    p->flag=true;
    strcpy(p->dic,earth);
}

void query(char *earth)
{
    int len=strlen(earth);
    node *p;
    p=root;
    for(int i=0;i<len;i++)
    {
        if(p->next[earth[i]-'a']==NULL)
        {
            printf("%s",earth);
            return;
        }
        p=p->next[earth[i]-'a'];
    }
    if(p->flag)
        printf("%s",p->dic);
    else
        printf("%s", earth);
}


int main()
{
    char earth[15],mars[15],ask[3010];


    scanf("%s",earth);
    root=build();
    while(scanf("%s",earth),strcmp(earth,"END"))
    {
        scanf("%s",mars);
        insert(earth,mars);
    }


    scanf("%s",earth);
    getchar();
    while(gets(ask),strcmp(ask,"END"))
    {
        int len=strlen(ask);
        for(int i=0;i<len;i++)
        {
            if(islower(ask[i]))
            {
                int j=0;
                memset(earth,'\0',sizeof(earth));
                while(islower(ask[i]))
                    earth[j++]=ask[i++];
                query(earth);
            }
            if(!islower(ask[i]))
                printf("%c",ask[i]);
        }
        printf("\n");
    }

    return 0;
}
（3）实现搜索引擎的热门搜索排名
我的初步想法是和(1)类似，对（1）中的trie进行先序遍历，将字符串和出现次数存进一个结构体，最后对这个数组进行快速排序，时间复杂度为O(nlogn),看网上说可以利用分治+trie
+最小堆，我还没有仔细搞清楚，以后研究完在添加。
（4）输入自动补全
其实原理都差不多，把字符串结尾处的结点当作root，进行先序遍历，即可得出所有以输入的字符串为前缀的答案。 

/ 自动补全 
#include <cstdio>
#include <iostream>
#include <string>
#include <cstring>
using namespace std;
const int MAXN=26;
typedef struct Trie_Node
{
   	int count;      //单词出现的次数 
   	struct Trie_Node* next[MAXN];    //指向各个子树的指针 
	bool exist;    //标记结点处是否构成单词 
	char name[15];
}Trie;
Trie* createNode()
{
	Trie* p =(Trie*)malloc(sizeof(Trie));
	p->count=0;
	p->exist=false;
	memset(p->next,0,sizeof(p->next));
	return p;
}
void Insert(Trie *root,char* word)
{
	Trie *p=root;
	char *s=word;
	while(*s!='\0')
	{
		if(p->next[*s-'a']==NULL)
		{
			p->next[*s-'a']=createNode();
		}
		p=p->next[*s-'a'];
        ++s; 
	}
	 p->exist=true; 
	  p->count+=1;
   strcpy(p->name,word);
}

Trie* Search(Trie* root, char* s)
{
	Trie *p=root;
	while(*s!='\0')
	{
		p=p->next[*s-'a'];
		if(p==NULL)
		return 0;
		++s;
	}
	return p;
}

void del(Trie *root)
{
	for(int i=0;i<MAXN;i++)
	{
		if(root->next[i]!=NULL)
		{
		   del(root->next[i]);	
		}
	}
	free(root);   

}
void Print(Trie *root)
{
	Trie *p=root;
	if(p->exist)
	cout<<p->name<<": "<<p->count<<endl;
	for(int i=0;i<26;i++)
	{
		if(p->next[i]!=NULL){
			Print(p->next[i]);
		}
	} 
} 
int main()
{
	char s[15];
	Trie* root=createNode();
	for(int i=0;i<5;i++)
	{
		cin>>s;
		Insert(root,s);
	}
	while(cin>>s)
	{
		Trie *ans=Search(root,s);
        if(ans)
		Print(ans);
	}
	del(root);
	return 0;
}



NK_test
关注
  • 7
    点赞
  • 踩
  • 37
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
Trie树(字典树)的介绍及Java实现
08-31
Trie树，又称字典树或前缀树，关于它的结构就不详细介绍了。Trie树在单词统计、前缀匹配等很多方面有很大用处。下面这篇文章主要介绍了Trie树，以及Java实现如何Trie树，有需要的朋友可以参考借鉴，下面来一起看看吧。
PHP字典树(Trie树)定义与实现方法示例
10-19
主要介绍了PHP字典树(Trie树)定义与实现方法,简单描述了字典树的概念并结合实例形式分析了字典树的定义与使用方法,需要的朋友可以参考下
Trie树（详解+例题）
最新发布
m0_67717626的博客
03-16 1204
Trie树，即字典树，又称单词查找树或键树，是一种树形结构，每个节点保存一个字符，一条路径表示一个字符串。它的优点是：利用字符串的公共前缀来减少查询时间，最大限度地减少无谓的字符串比较。Trie的核心思想是空间换时间。利用字符串的公共前缀来降低查询时间的开销以达到提高效率的目的。
详解字典树Trie结构及其Python代码实现
09-21
Trie多被用来查找和统计字符串,利用公共前缀来减少搜索时间,下面我们就来详解字典树Trie结构及其Python代码实现
T9输入法的实现
To be a crazy and happy coder!
03-30 7418
T9输入法，名字听起来陌生，可是大家却经常使用它。可以说T9输入法是输入法历史中的一次革命。至少自T9输入法开始，输入法有长足的进步。 如图手机中九个数字键。26个英文字母被分配到2至9这8个数字键上。以前想输入英文单词的时候总是需要连续多次按某个键，才能得到目标字母。比如想输入“hello”，就需要按两次4，两次3，三次5，三次5，三次6.输入一个单词需要数十次的按键，更何况还有经常按错的情况
Trie树总结
weixin_55851276的博客
06-05 607
关于Trie树的总结
【数据结构】前缀树/字典树
代码星辰的博客
01-10 634
本文介绍了前缀树/字典树的概述、代码实现以及应用。
数据结构：Trie树
妄北y
02-10 2359
数据结构：Trie树
Trie树的实现(思路分析)
m0_57001006的博客
11-22 368
我们的Trie树是一个多叉树, 而不是一个二叉树, 所以结点类中的子节点不止有左右子结点, 子节点有多个, 因此我们一般都是直接声明一个子节点数组我们此时是要做一个单词字典树, 所以这个树最多是一个26叉树, 所以我们的子节点数组长度都定为26即可。
Trie树的实现
warringah的专栏
08-07 849
Trie树的实现 一、定义： Trie，又称字典树，是一种用于快速检索的二十六叉树结构。典型的空间换时间   二、结构图： 三、原理： Trie把要查找的关键词看作一个字符序列，并根据构成关键词字符的先后顺序检索树结构； 特别地：和二叉查找树不同，在Trie树中，每个结点上并非存储一个元素。   四、性质： 0、利用串的公共前缀，节约内存 1、在trie树上进行检
程序员面试金典 - 面试题 17.13. 恢复空格（DP+Trie树）
Michael是个半路程序员
04-14 898
文章目录1. 题目2. 解题2.1 动态规划 1. 题目 哦，不！你不小心把一个长篇文章中的空格、标点都删掉了，并且大写也弄成了小写。 像句子"I reset the computer. It still didn’t boot!"已经变成了"iresetthecomputeritstilldidntboot"。 在处理标点符号和大小写之前，你得先把它断成词语。 当然了，你有一本厚厚的词典dict...
IT笔试面试--Trie树前缀树常考题目及解析
04-14
IT笔试面试--Trie树前缀树常考题目及解析，包含了Trie树的常考题目，以及详细的解析
trie树的实现（C）
05-18
trie.c中定义了trie树的操作函数； trie.h为相应的头文件； test.c用于测试相关的函数。 在trie.c中，关于查找定义了两个函数，一个是find()，一个是search()，二者的区别是，前者仅判断一个字符串是否在树中出现，而后者除了判断字符串是否出现，还会判断待查找的字符串是否是一个合法的单词。
Trie树_字典树(字符串排序)简介及实现
10-26
有时，我们会碰到对字符串的排序，若采用一些经典的排序算法，则时间复杂度一般为O(n*lgn)，但若采用Trie树，则时间复杂度仅为O(n)
POJ 1451 T9（Trie+思维）
C_Dreamy的博客
02-15 204
Description Background A while ago it was quite cumbersome to create a message for the Short Message Service (SMS) on a mobile phone. This was because you only have nine keys and the alphabet has more than nine letters, so most characters could only be en
208_实现Trie（前缀树）_字符串_中等
HYN205的博客
04-02 363
原题：https://leetcode-cn.com/problems/implement-trie-prefix-tree https://leetcode-cn.com/problems/implement-trie-prefix-tree/solution/shi-xian-trie-qian-zhui-shu-by-leetcode/ 实现一个 Trie (前缀树)，包含 inser...
Trie树（字典树&前缀树）
小朱小朱绝不认输的博客
05-16 1406
Trie树的学习 文章目录1. Trie树的基本知识2. Trie树的实现2.1 二维数组实现2.2 TrieNode实现2.3 方法对比2.4 问题分析 1. Trie树的基本知识 Trie 树（又叫「前缀树」或「字典树」）是一种用于快速查询「某个字符串/字符前缀」是否存在的数据结构。 Trie 树的本质，就是利用字符串之间的公共前缀，将重复的前缀合并在一起。 Trie树是一种哈希树的变种。 典型应用：用于统计和排序大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。 优点：最大限度
Trie树
weixin_47251999的博客
01-29 8989
基本概念 Trie 树，也叫“字典树”。顾名思义，它是一个树形结构。它是一种专门处理字符串匹配的数据结构，用来解决在一组字符串集合中快速查找某个字符串的问题。 Trie 树的本质，就是利用字符串之间的公共前缀，将重复的前缀合并在一起： Trie树的操作 Trie树是为匹配字符串而准备的，所以我们需要预先建立一个Trie树： 构造Trie树 但实际上构造Trie树，是利用数组（每个节点是字符值+下一字符的索引）： 纯26个小写英文字母匹配，可以通过字符的 ASCII 码减去“a”的 ASCII 码，迅
HDU 1298 - T9(trie树)
转移到dawxy.com
11-26 547
题目链接 HDU1298 【题意】给出n( or 2,np 1,nh 3，则串n出现概率为1+3,nh为3，np为1，o为2，or为2；然后求出每次输入手机键盘按钮时对应的概率最大的子串(不一定要出现的字符串，他们前缀都可以)。 【分析】一开始题意理解错了，以为概率为路径之和，知道题意后，还是蛮好写的，只要把字典树的查询改一下，用dfs完成，每次控制下可以查询的字符串(手机键盘数字对应的3，
c语言字典trie树代码实现
05-30
以下是一个简单的 C 语言字典 Trie 树的代码实现： ```c #include #include #include #define MAX_WORD_LEN 100 typedef struct TrieNode { char value; struct TrieNode *children[26]; int is_end; } ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值