百度suggestion功能的Trie实现(附代码)

相信大家都使用过百度搜索框的suggestion功能，百度搜索框中的suggestion提示功能如何实现？请给出实现思路和主要的数据结构、算法。有什么优化思路可以使得时间和空间效率最高？   

这个题的基础实现方法是使用Trie树， 原理部分摘用别的.      (代码部分我增加了findTips功能， 这里采用方法1,空间要求最大 26^n,,若是汉字，那不能使用了。)

树的结构可以有这三种实现方法 ：

一般有三种方法：

1、对每个结点开一个字母集大小的数组，对应的下标是儿子所表示的字母，内容则是这个儿子对应在大数组上的位置，即标号；

2、对每个结点挂一个链表，按一定顺序记录每个儿子是谁；

3、使用左儿子右兄弟表示法记录这棵树。

三种方法，各有特点。第一种易实现，但实际的空间要求较大；第二种，较易实现，空间要求相对较小，但比较费时；第三种，空间要求最小，但相对费时且不易写。

http://zhangzhibiao02005.blog.163.com/blog/static/373678202010667524646/

昨天在北邮人bbs上逛时，看到有人在讨论字符窜提示的问题，有人回帖用trie树来做，而我以前也听过trie树，不过想系统学习下，于是大概用了一个下午的时间来学习trie树。网上有很多关于trie树的资料，其核心思想就时拿空间换取时间，很适合搜索前缀子窜，时间效率比较高，主要是占用空间比较大。为什么会这样呢？看下trie树的结构就知道拉。

如图所示，该trie树存有abc、d、da、dda四个字符串，如果是字符串会在节点的尾部进行标记。没有后续字符的branch分支指向NULL

已知n个由小写字母构成的平均长度为10的单词,判断其中是否存在某个串为另一个串的前缀子串。下面对比3种方法：

1.    最容易想到的：即从字符串集中从头往后搜，看每个字符串是否为字符串集中某个字符串的前缀，复杂度为O(n^2)。

2.    使用hash：我们用hash存下所有字符串的所有的前缀子串。建立存有子串hash的复杂度为O(n*len)。查询的复杂度为O(n)* O(1)= O(n)。

3.    使用trie：因为当查询如字符串abc是否为某个字符串的前缀时，显然以b,c,d....等不是以a开头的字符串就不用查找了。所以建立trie的复杂度为O(n*len)，而建立+查询在trie中是可以同时执行的，建立的过程也就可以成为查询的过程，hash就不能实现这个功能。所以总的复杂度为O(n*len)，实际查询的复杂度只是O(len)

解释一下hash为什么不能将建立与查询同时执行，例如有串：911，911456输入，如果要同时执行建立与查询，过程就是查询911，没有，然后存入9、91、911，查询911456，没有然后存入9114、91145、911456，而程序没有记忆功能，并不知道911在输入数据中出现过。所以用hash必须先存入所有子串，然后for循环查询。

而trie树便可以，存入911后，已经记录911为出现的字符串，在存入911456的过程中就能发现而输出答案；倒过来亦可以，先存入911456，在存入911时，当指针指向最后一个1时，程序会发现这个1已经存在，说明911必定是某个字符串的前缀，

trie树的简单实现(增加了findTips功能）：

[cpp] view plaincopy

1. #include <iostream>  
2. #include <cstdlib>  
3. #include <string>  
4. #include <string.h>  
5. #include <vector>  
6.   
7. using namespace std;  
8.   
9. const int branchNum = 26;  
10.   
11. struct TrieNode   
12. {  
13.     bool isStr;  
14.     TrieNode *next[branchNum];  
15.     TrieNode()  
16.         :isStr(false)  
17.     {  
18.         memset(next , 0  , sizeof(next));  
19.     }  
20. };  
21.   
22. class Trie  
23. {  
24. public:  
25.     Trie();  
26.     void insert(const char *word);  
27.     bool search(const char *word);  
28.     void deleteTrie(TrieNode *root);  
29.     vector<string> findTips(const char *prefix); //here  
30.     void findTips(TrieNode *root , string track , vector<string> &tips); //here  
31. private:  
32.     TrieNode *root;  
33. };  
34.   
35. Trie::Trie()  
36. {  
37.     root = new TrieNode(); //绗竴涓猲ode鏃犵敤  
38. }  
39.   
40. void Trie::insert(const char *word)  
41. {  
42.     TrieNode *location = root;  
43.     while(*word) {  
44.         if(location->next[*word - 'a'] == NULL) {  
45.             TrieNode *tmp = new TrieNode();  
46.             location->next[*word - 'a'] = tmp;  
47.         }  
48.         location = location->next[*word - 'a'];  
49.         word++;  
50.     }  
51.     location->isStr = true;  
52. }  
53.   
54. bool Trie::search(const char *word)  
55. {  
56.     TrieNode *location = root;  
57.     while(*word && location) {  
58.         location = location->next[*word - 'a'];  
59.         word ++;  
60.     }  
61.     return (location != NULL && location->isStr);  
62. }  
63.   
64. void Trie::deleteTrie(TrieNode *root)  
65. {  
66.     for(int i = 0 ; i < branchNum ; i++) {  
67.         if(root->next[i] != NULL) {  
68.             deleteTrie(root->next[i]);  
69.         }  
70.     }  
71.     delete root;  
72. }  
73.   
74. vector<string> Trie::findTips(const char *prefix)  
75. {  
76.     vector<string> tips;  
77.     string track(prefix);  
78.     int i;  
79.     struct TrieNode *node;  
80.   
81.     for(i = 0 ,node = root ; i < strlen(prefix) && node != NULL ; i++) {  
82.         node = node->next[prefix[i] - 'a'];  
83.     }  
84.     if(node == NULL && i != strlen(prefix))  
85.       return tips; //empty  
86.       
87.   
88.     findTips(node, track , tips);  
89.     return tips;  
90. }  
91.   
92. void Trie::findTips(TrieNode *root,string track , vector<string> &tips) //track长度最多为最长字符串长度，  
93. {  
94.   
95.     if(root == NULL)  
96.         return;  
97.   
98.     if(root->isStr)  
99.         tips.push_back(track);  
100.   
101.     for(int i = 0 ; i < branchNum ; i++) {  
102.         findTips(root->next[i] , track + (char)('a'+i) , tips);  
103.     }  
104. }  
105.   
106. int main()  
107. {  
108.     Trie t;  
109.     t.insert("a");  
110.     t.insert("abandon");  
111.     t.insert("abandoned");  
112.     t.insert("abashed");  
113.     if(t.search("abashed"))  
114.         cout << "true" << endl;  
115.   
116.     vector<string> tips = t.findTips("ab");  
117.     cout << "ab" << " tips are :(" << tips.size() <<")" <<endl;  
118.     for(int i = 0 ; i < tips.size() ; i ++)  
119.         cout << tips[i] << endl;  
120.       
121.   
122.   
123. }  

运行后出来结果：

true
ab tips are :(3)
abandon
abandoned
abashed

至于优化的话，也许在Trie树的实现就可以进行优化。向这种实现方式的化，每个节点就得包括所有的字符集。如果换成汉字，那就是每个结点上千个了。

注意：对于汉字的话，可以弄一个索引，比如0代表啊，1代码阿，等等 ， 就无法使用了。

树的深度就是最长的单词长度 。。 

比如：http://linux.thai.net/~thep/datrie/datrie.html#Double双数组的实现方式