trie树简介

最新推荐文章于 2022-02-17 22:37:38 发布
最新推荐文章于 2022-02-17 22:37:38 发布
阅读量1.4k 收藏 1
点赞数
分类专栏： 结构与算法

本博客（http://blog.youkuaiyun.com/livelylittlefish ）贴出作者（阿波）相关研究、学习内容所做的笔记，欢迎广大朋友指正！

Content

1. trie基础

(1) 是什么？

(2) 性质

(3) 应用

(4) 优点

2. 一个例子

(1) 功能

(2) 代码

(3) 运行结果

(4) 分析

3. 一点点修改

(1) 分析

(2) 修改

(3) 代码

(4) 运行结果

(5) 分析

(6) 一个稍微复杂点的结果

4. 小结

 

 

1. trie基础

 

(1) 是什么？

Trie，又称单词查找树或键树，是一种树形结构，是一种哈希树的变种。

 

(2) 性质

  • 根节点不包含字符，除根节点外每一个节点都只包含一个字符
  • 从根节点到某一节点，路径上经过的字符连接起来，为该节点对应的字符串
  • 每个节点的所有子节点包含的字符都不相同

 

例如，单词序列a, to, tea, ted, ten, i, in, inn，对应的trie。

(3) 应用

用于统计和排序大量的字符串，但不仅限于字符串，所以经常被搜索引擎系统用于文本词频统计。

 

(4) 优点

  • 最大限度地减少无谓的字符串比较
  • 查询效率比哈希表高

 

2. 一个例子

 

该列子从中文wiki百科而来。

 

(1) 功能

 

从控制台输入字符串，每个字符串以回车结束，所有字符串的输入以'#'结束。程序统计输入的所有字符串中每种字符串的出现次数。

 

(2) 代码

 

一个实现了该功能的例子代码如下。

[cpp]  view plain copy
  1. /** 
  2.  * trie tree test 
  3.  * descriptioin: make statistics on every word for its frequency 
  4.  * usage: input some strings, each followed by a 'enter' character, and end with '#' 
  5.  */  
  6. #include <stdio.h>  
  7. #include <stdlib.h>  
  8. #include <string.h>  
  9. #define Max_Char_Number 256  
  10. #define Max_Word_Len      128  
  11. struct Trie_Node  
  12. {  
  13.     int count_;  
  14.     struct Trie_Node *next_[Max_Char_Number];  
  15. };  
  16. static struct Trie_Node root= {0, {NULL}};  
  17. static char *spaces=" /t/n/./"/'()";  
  18. static int insert(const char *word)  
  19. {  
  20.     int loop;  
  21.     struct Trie_Node *cur, *newnode;  
  22.     if (word[0] == '/0')  
  23.         return 0;  
  24.     cur = &root;  
  25.     for (loop=0; ; ++loop)  
  26.     {  
  27.         if (cur->next_[word[loop]] == NULL)  
  28.         {  
  29.             newnode=(struct Trie_Node*)malloc(sizeof(struct Trie_Node));  
  30.             memset(newnode, 0, sizeof(struct Trie_Node));  
  31.             cur->next_[word[loop]] = newnode;  
  32.         }  
  33.         if (word[loop] == '/0')  
  34.             break;  
  35.         cur = cur->next_[word[loop]];  
  36.     }  
  37.     cur->count_++;  
  38.     return 0;  
  39. }  
  40. void input()  
  41. {  
  42.     char *linebuf = NULL, *line = NULL, *word = NULL;  
  43.     size_t bufsize=0;  
  44.     int ret;  
  45.     while (1)  
  46.     {  
  47.         ret=getline(&linebuf, &bufsize, stdin);  
  48.         if (ret==-1)  
  49.             break;  
  50.         line=linebuf;  
  51.         word = strsep(&line, spaces);  
  52.         /* input '#' will terminate this input */  
  53.         if (strcmp(word, "#") == 0)  
  54.             break;  
  55.         if (word[0]=='/0')  
  56.             continue;  
  57.         insert(word);  
  58.     }  
  59. }  
  60. static void printword(const char *str, int n)  
  61. {  
  62.     printf("%s/t%d/n", str, n);  
  63. }  
  64. static int traverse(struct Trie_Node *rootp)  
  65. {  
  66.     static char worddump[Max_Word_Len+1];  
  67.     static int pos=0;  
  68.     int i;  
  69.     if (rootp == NULL)  
  70.         return 0;  
  71.     if (rootp->count_)  
  72.     {  
  73.         worddump[pos]='/0';  
  74.         printword(worddump, rootp->count_);  
  75.     }  
  76.     for (i=0; i<Max_Char_Number; ++i)  
  77.     {  
  78.         worddump[pos++]=i;  
  79.         traverse(rootp->next_[i]);  /* recursive call */  
  80.         pos--;  
  81.     }  
  82.     return 0;  
  83. }  
  84. void dump(struct Trie_Node* node)  
  85. {  
  86.     static int depth = 0;  
  87.     static const char prefix[] = "    ";  
  88.     int loop = 0;  
  89.     if (node == NULL)  
  90.         return;  
  91.     for (loop = 0; loop < Max_Char_Number; loop++)  
  92.     {  
  93.         if (node->next_[loop])  
  94.         {  
  95.             printf ("%.*s", (int) depth++, prefix);  
  96.             printf("next['%c'] = 0x%x, count = %d/n", loop, (unsigned int)(node->next_[loop]), node->next_[loop]->count_);  
  97.             dump(node->next_[loop]);  /* recursive call */  
  98.             depth--;  
  99.         }  
  100.     }  
  101. }  
  102. int main(void)  
  103. {  
  104.     input();  
  105.     printf("/n");  
  106.     traverse(&root);  
  107.     printf("/n");  
  108.     dump(&root);  
  109.     return 0;  
  110. }  

(3) 运行结果

# ./trie

a

to

tea

ted

ten

i

in

inn

#

 

a       1

i       1

in      1

inn     1

tea     1

ted     1

ten     1

to      1

 

next['a'] =0x88c1088, count = 1

 next[''] = 0x88c1490, count = 0

next['i'] =0x88c40e8, count = 1

 next[''] = 0x88c44f0, count = 0

 next['n'] = 0x88c48f8, count = 1

  next[''] = 0x88c4d00, count = 0

  next['n'] = 0x88c5108, count = 1

   next[''] = 0x88c5510, count = 0

next['t'] =0x88c1898, count = 0

 next['e'] = 0x88c24b0, count = 0

  next['a'] = 0x88c28b8, count = 1

   next[''] = 0x88c2cc0, count = 0

  next['d'] = 0x88c30c8, count = 1

   next[''] = 0x88c34d0, count = 0

  next['n'] = 0x88c38d8, count = 1

   next[''] = 0x88c3ce0, count = 0

 next['o'] = 0x88c1ca0, count = 1

  next[''] = 0x88c20a8, count = 0

 

(4) 分析

 

在该程序中，笔者加入了dump函数，递归地打印出next数组中不为空的值，如下图所示。

 

加上次数，如下图。其中边(包括实边和虚边)上的数字即为next数组的下标，该数字即为该边所到节点字符的ASCII码。程序中使用字符本身，实际上是该字符的ASCII码，作为next数组下标，这样能够获得o(1)的访问效率，无需查找，直接访问。

 

 

由图直接看出，根节点的

next[97]出现的次数为1，即字符串"a"的次数；

next[105]的次数也为1，即字符串"i"的次数；

next[105]->next[110]出现的次数为1，即字符串"in"的次数；

next[105]->next[110]->next[110]出现的次数为1，即字符串"inn"的次数；

...

 

感觉怎样？是不是很直观呢？

——of course!

 

3. 一点点修改

 

(1) 分析

 

如上述例子，程序已经统计出next[105]->next[110]出现的次数为1，即字符串"in"的次数为1，为什么next[105]->next[110]->next[0]还有值呢？即next[0]这个指针实际上还指向一个节点，虽然该节点的值全为0。

 

如果被统计的字符串数量庞大，叶子节点数量庞大，或者如上图'i'这样的节点数量庞大，那么，空间的浪费也是很显然的，因为从程序中，我们知道，每个节点的大小sizeof(struct Trie_Node)=1028字节。如果，这样的节点有10000个，则浪费1028*10000字节，大约10M。

 

(2) 修改

 

调试上面的代码，发现insert函数，即向tire树中插入一个字符串时，for循环的退出条件可以修改，如下。

 

static int insert(const char *word)

{

    int loop;

    struct Trie_Node*cur, *newnode;

 

 

    if (word[0] == '/0')

        return 0;

 

    cur = &root;

    for (loop=0; ; ++loop)

    {

        if (word[loop] == '/0')  /* the break condition should be here */

            break;

 

        if (cur- >next_[word[loop]] == NULL)

        {

            newnode=(struct Trie_Node*)malloc(sizeof(struct Trie_Node));

            memset(newnode, 0, sizeof(struct Trie_Node));

            cur- >next_[word[loop]] = newnode;

        }

 

        cur = cur- >next_[word[loop]];

    }

    cur- >count_++;

 

    return 0;

}

 

(3) 代码

 

省略。

 

(4) 运行结果

 

# ./trie

a

to

tea

ted

ten

i

in

inn

#

 

a       1

i       1

in      1

inn     1

tea     1

ted     1

ten     1

to      1

 

next['a'] =0x8bb8088, count = 1

next['i'] =0x8bb9cc0, count = 1

 next['n'] = 0x8bba0c8, count = 1

  next['n'] = 0x8bba4d0, count = 1

next['t'] =0x8bb8490, count = 0

 next['e'] = 0x8bb8ca0, count = 0

  next['a'] = 0x8bb90a8, count = 1

  next['d'] = 0x8bb94b0, count = 1

  next['n'] = 0x8bb98b8, count = 1

 next['o'] = 0x8bb8898, count = 1

 

(5) 分析

 

对比修改前后的运行结果发现，修改后的程序中不再含有next[0]的节点。如下图。

由上图也可直接看出，根节点的

next[97]出现的次数为1，即字符串"a"的次数；

next[105]的次数也为1，即字符串"i"的次数；

next[105]->next[110]出现的次数为1，即字符串"in"的次数；

next[105]->next[110]->next[110]出现的次数为1，即字符串"inn"的次数；

...

 

相比修改前的图，该图没有next[0]的垃圾数据，更直观。

 

(6) 一个稍微复杂点的结果

 

# ./trie

a

to

tea

ted

ten

i

in

inn

a

to

tea

ted

ten

i

in

inn

a

i

a

a

#

 

a       5

i       3

in      2

inn     2

tea     2

ted     2

ten     2

to      2

 

next['a'] =0x9604088, count = 5

next['i'] =0x9605cc0, count = 3

 next['n'] = 0x96060c8, count = 2

  next['n'] = 0x96064d0, count = 2

next['t'] =0x9604490, count = 0

 next['e'] = 0x9604ca0, count = 0

  next['a'] = 0x96050a8, count = 2

  next['d'] = 0x96054b0, count = 2

  next['n'] = 0x96058b8, count = 2

 next['o'] = 0x9604898, count = 2

 

4. 小结

 

本文简单介绍了tire树的基本概念，并用一个例子说明其应用。

在设计程序时，可以使用一些小的技巧来提高程序效率，例如本文采用字符本身，即其ASCII码值，作为next数组下标，获得o(1)的访问效率。也要注意使用(循环)边界条件，消除垃圾数据。

 

 

reference

http://zh.wikipedia.org/wiki/Trie

http://en.wikipedia.org/wiki/Trie
http://en.wikipedia.org/wiki/Hash_trie

http://en.wikipedia.org/wiki/Hash_array_mapped_trie

http://www.topcoder.com/tc?module=Static&d1=tutorials&d2=usingTries

TRIE（1）
mathor的博客
08-14 441
 Trie又被称为前缀树或者字典树。它的基本作用是用来存储一个字符串集合：{W1, W2, W3, … WN}，并且可以用来查询一个字符串S是不是在集合里  具体来说，Trie一般支持两个操作： 1. Trie.insert(W)：第一个操作是插入操作，就是将一个字符串W加入到集合中 2. Trie.search(S)：第二个操作是查询操作，就是查询一个字符串S是不是在集合中  由于Tri...
Trie
Wilbert的博客
12-13 638
今天照例，写了一发hihocoder，是关于Trie字典树的，于是顺便再复习下字典树吧。 Trie是一种树，非常实用的一种树，使用Trie还可以写AC自动机。在字符串处理上面有非常好的效率。 首先介绍下字典树的定义。 在使用C++的时候，可以这么定义字典树#define N 26 //字典树中的字母数量 typedef struct node{ int num;
Trie 树（数据结构）
zgdlxs的博客
01-23 8077
1.Trie树的概念 Trie树是数据结构比较简单的一种。Trie 树的基本用法是高效的存储和查找字符串集合的数据结构。Trie树也叫做字典树，它是一个树形结构。是一种专门处理字符串匹配的数据结构，用来解决在一组字符串集合中快速查找某个字符串。Trie树本质，利用字符串之间的公共前缀，将重复的前缀合并在一起。 2.Trie树的操作 2.1存储 Trie树的存储是从根节点开始从前往后依次便利每一个字符。 ...
Trie树_字典树(字符串排序)简介及实现
10-26
Trie树，又称字典树、单词查找树，是一种用于处理字符串相关问题的高效数据结构。其核心思想是通过空间换时间，利用字符串的公共前缀来节约存储空间，并减少无谓的字符串比较，从而达到快速查找、插入和删除字符串的...
Trie树及其优化
Rhine
10-10 1908
介绍Trie树及Double Array Trie优化
Trie 树实现的源码
12-14
#### 一、Trie树简介 Trie树，也称为前缀树或字典树，是一种用于存储字符串数据结构。它利用字符串间的公共前缀来减少所需的存储空间，使得查找字符串更加高效。Trie树在很多应用中都有广泛的应用，如拼写检查、自动...
Trie树c++实现
weixin_41247488的博客
02-17 903
Trie树简介 Trie树又称字典树，是一种用于实现字符串快速检索的多叉树结构。Trie树的每个节点都有若干个字符指针，若在插入或检索字符串时扫描到一个字符c，就沿着当前节点的c这个字符指针，走向该指针指向的节点。 实现原理 上面的简介看懂了吗？我没有为了加深理解，还是模拟一下： 先插入“cat”： 再插入“dog”： 接着，插入“deer”： 最后，插入“panda”： 如上图，我们便成功地构建了一棵Trie树。其空间复杂度为 O(NC)O(NC)O(NC) （其中，N是节点个数，C是字符集的大小
数据结构-----基于双数组的Trie树
一个程序渣渣的小后院
05-24 3194
Trie树简介Trie树也称字典树，在字符串的查找中优势比较明显，适用于在海量数据中查找某个数据。因为Trie树的查找时间和数据总量没有关系，只和要查找的数据长度有关。比如搜索引擎中热度词语的统计。除此之外也可用于将数据按字典序排序。 另外Trie树是典型的空间换时间的数据结构，构建一颗Trie树需要花费比较大的内存空间。简单的Trie树的实现有两种方式，每个节点存储一个子节点数组，或者用链表将每
Trie树
小蒟蒻yyb的博客
07-10 8030
Trie树即字典树 以下内容来自某度某科在计算机科学中，trie，又称前缀树或字典树，是一种有序树，用于保存关联数组，其中的键通常是字符串。与二叉查找树不同，键不是直接保存在节点中，而是由节点在树中的位置决定。 在计算机科学中，trie，又称前缀树或字典树，是一种有序树，用于保存关联数组，其中的键通常是字符串。与二叉查找树不同，键不是直接保存在节点中，而是由节点在树中的位置决定。一个节点的所有子
acwing.835.Trie字符串统计
qq_47997583的博客
04-14 614
Trie字符串统计 维护一个字符串集合，支持两种操作： I x 向集合中插入一个字符串 x； Q x 询问一个字符串在集合中出现了多少次。 共有 N 个操作，输入的字符串总长度不超过 105，字符串仅包含小写英文字母。 输入格式 第一行包含整数 N，表示操作数。 接下来 N 行，每行包含一个操作指令，指令为 I x 或 Q x 中的一种。 输出格式 对于每个询问指令 Q x，都要输出一个整数作为结果，表示 x 在集合中出现的次数。 每个结果占一行。 数据范围 1≤N≤2∗104 输入样例： 5 I abc
请你用几句话介绍trie树构建介绍
最新发布
03-24
<think>好的，用户想了解Trie树的构建方法、简介以及应用场景，还有数据结构和算法相关内容。首先我需要回忆Trie树的基本概念。根据引用[4]，Trie树又叫前缀树，是一种树形数据结构，用于高效存储和检索字符串集合中的键。公共前缀的节点路径相同，节省空间。 接下来，构建方法部分。引用[1]提到构造过程是逐步插入字符串，每个插入操作对应树的一个节点扩展。可能需要详细描述插入步骤，比如从根节点开始，逐个字符检查子节点是否存在，不存在则创建新节点，直到字符串结束标记。引用[3]也提到类似哈夫曼编码的压缩特性，公共前缀只存储一次，所以构建时要注意共享前缀的结构。 应用场景方面，引用[2]和[5]提到中文分词、数据压缩、单词检测等。比如单词语法检查，利用Trie树快速查找是否存在。引用[4]还提到自动补全和拼写检查，这些需要前缀匹配的场景很适合。 数据结构和算法部分，需要说明Trie树的节点结构，通常是每个节点包含子节点的指针数组和一个结束标志。插入、查询的时间复杂度，比如O(L)，L是字符串长度。还要比较优缺点，如查询效率高但空间消耗可能大，引用[4]中的优缺点部分需要整合。 用户可能的问题包括构建步骤的具体例子，如何优化空间，与哈希表的比较，以及实际应用案例。需要确保回答中涵盖这些点，并引用合适的参考资料。例如，在构建时用示例分解步骤，可能像引用[1]中的图示过程。优化部分可以提到压缩Trie树，如引用[2]中的方法，但准确性可能受影响。 需要注意的是，用户要求用中文回答，数学公式用$...$，独立公式用$$...$$，但Trie树可能涉及较少数学公式，更多是结构描述。需要检查是否有变量或表达式需要格式处理，比如节点数量或时间复杂度的大O表示法，可能需要用行内公式。 最后，生成相关问题时要围绕Trie树的构建、优化、应用差异等，比如空间优化方法，与哈希表的对比，前缀匹配实现方式等。确保问题覆盖用户可能感兴趣的扩展方向。</think>### Trie树简介及构建方法 #### 1. Trie树是什么？ Trie树（字典树、前缀树）是一种树形数据结构，主要用于**高效存储和检索字符串集合**。其核心特点是： - 节点不直接存储字符，而是通过**路径表示字符**； - 公共前缀的字符串共享树中的路径，例如"apple"和"app"在树中共享前三个字符的路径[^4]； - 典型结构包含**根节点、子节点指针数组、结束标志**（标记字符串末尾）。 #### 2. 如何构建Trie树？ **构建步骤**： 1. **初始化根节点**：根节点为空，不包含字符。 2. **插入字符串**： - 从根节点开始，逐字符遍历字符串； - 若当前字符对应的子节点存在，则移动到该子节点； - 若不存在，则创建新节点并链接到父节点； - 重复直至字符串末尾，标记结束标志[^1]。 3. **重复插入**：对所有字符串执行上述操作。 **示例**（插入"app"和"apple"）： ``` 根 → a → p → p（标记结束） ↘ p → l → e（标记结束） ``` #### 3. 时间复杂度与空间复杂度 - **插入/查询**：$O(L)$（$L$为字符串长度） - **空间复杂度**：最坏情况$O(N \cdot L)$（$N$为字符串数量） #### 4. 优缺点对比 | 优点 | 缺点 | |------|------| | 前缀匹配高效 | 空间占用较高 | | 适合动态字符串集合 | 非字符串场景适用性低 | | 避免哈希冲突 | 实现复杂度较高 | #### 5. 应用场景 1. **自动补全**：输入前缀时快速匹配候选词（如搜索引擎）； 2. **拼写检查**：检测单词是否存在词典中[^5]； 3. **中文分词**：利用公共前缀压缩存储分词结果[^2]； 4. **IP路由表**：最长前缀匹配优化路由查找； 5. **数据压缩**：通过共享前缀减少存储冗余[^3]。 --- ### 代码示例（Python实现） ```python class TrieNode: def __init__(self): self.children = {} self.is_end = False class Trie: def __init__(self): self.root = TrieNode() def insert(self, word): node = self.root for char in word: if char not in node.children: node.children[char] = TrieNode() node = node.children[char] node.is_end = True def search(self, word): node = self.root for char in word: if char not in node.children: return False node = node.children[char] return node.is_end ``` ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值