1. Trie树介绍
Trie，又称单词查找树、前缀树，是一种多叉树结构。如下图所示：
上图是一棵Trie树，表示了关键字集合{“a”, “to”, “tea”, “ted”, “ten”, “i”, “in”, “inn”} 。
与二叉查找树不同，键不是直接保存在节点中，而是由节点在树中的位置决定。一个节点的所有子孙都有相同的前缀，也就是这个节点对应的字符串，而根节点对应空字符串。
2. trie树性质：
1.根节点不包含字符，除根节点外的每一个节点都只包含一个字符。
2.从根节点到某一节点，路径上经过的字符连接起来，为该节点对应的字符串。
3.每个节点的所有子节点包含的字符都不相同。
3. trie树典型应用：
(1) 字符串检索
查找某一个单词是否在树中。思路就是从根节点开始一个一个字符进行比较：
如果沿路比较，发现不同的字符，则表示该字符串在集合中不存在。
如果所有的字符全部比较完并且全部相同，还需判断最后一个节点的标志位（标记该节点是否代表字符串最后一个字符）。
从而trie树可以设计为：
struct trie_node
{
bool isKey; // 标记该节点是否代表一个关键字
trie_node *children[26]; // 各个子节点
};
(2) 词频统计
Trie树常被搜索引擎系统用于文本词频统计。
思路：为了实现词频统计，我们可以修改节点结构，将ksKey用一个整型变量count来表示该节点为结尾的关键字的词频。对每一个关键字执行插入操作，若已存在，计数加1，若不存在，插入后count置1。
struct trie_node
{
int count; // 记录该节点代表的单词的个数
trie_node *children[26]; // 各个子节点
};
(3) 去除重复单词
建立字典树的过程就是给字符串去重的过程。
(4) 字符串排序
Trie树可以对大量字符串按字典序进行排序，思路也很简单：遍历一次所有关键字，将它们全部插入trie树，树的每个结点的所有儿子很显然地按照字母表排序，然后先序遍历输出Trie树中所有关键字即可。
(5) 最长公共前缀
查找N个单词的最长公共前缀
(6) 前缀匹配:
比如要找以“an”为前缀的字符串
4. trie树设计
为了计算英语字符串词频，trie树设计可以参考3.(2)词频统计。
以上设计中因为是英文字符，父节点保存孩子节点时直接用一个数组children[26]来保存了孩子节点。这种方式最快，但是并不是所有节点都会有很多孩子，所以这种方式浪费的空间太多。可以用一个链表来代替数据。这样我们就可以省下不小的空间，但是缺点是搜索的时候需要遍历这个链表，增加了时间复杂度。如果存储汉字，可以把链表代替为map，这样既加快了速度，又不至于太浪费空间。
5. trie树优点：
(1) 查询快。对于长度为m的键值，最坏情况下只需花费O(m)的时间；而BST需要O(m log n)的时间。 虽然hash 表时间复杂度是O(1)，但是，哈希搜索的效率通常取决于 hash 函数的好坏，若一个坏的 hash 函数导致很多的冲突，效率并不一定比Trie树高。
(2) 当存储大量字符串时，Trie耗费的空间较少。因为键值并非显式存储的，而是与其他键值共享子串。
6. trie树操作
(1) 初始化或清空：遍历Trie，删除所有节点，只保留根节点。
(2) 插入字符串
1. 设置当前节点为根节点，设置当前字符为插入字符串中的首个字符；
2. 在当前节点的子节点上搜索当前字符，若存在，则将当前节点设为值为当前字符的子节点；否则新建一个值为当前字符的子节点，并将当前结点设置为新创建的节点。
3. 将当前字符设置为串中的下个字符，若当前字符为0，则结束；否则转2.
(3) 查找字符串
搜索过程与插入操作类似，当字符找不到匹配时返回假；若全部字符都存在匹配，判断最终停留的节点是否为树叶，若是，则返回真，否则返回假。
(4) 输出字符串词频
(5) 删除字符串
首先查找该字符串，边查询边将经过的节点压栈，若找不到，则返回假；否则依次判断栈顶节点是否为树叶，若是则删除该节点，否则返回真。
(6) 输出字典树所有字符串
(7) 计算所有字符串的词频总数（包含重复或不重复）
(8) 计算字典树中所有单词的最长公共前缀及其长度
7. 实现
//使用字典树存储英文单词，使用的结构是26叉字典树。不区分单词的大小写
#include <cstring>
#include <iostream>
/* trie的节点类型 */
template <int Size> //Size为字符表的大小
struct trie_node
{
int freq; //当前节点是否可以作为字符串的结尾,如果是freq>0,如果存在重复单词，freq表示该单词的词频
int node; //子节点的个数
trie_node *child[Size]; //指向子节点指针
/* 构造函数 */
trie_node() : freq(0), node(0) { memset(child, 0, sizeof(child)); }
};
/* trie */
template <int Size, typename Index> //Size为字符表的大小，Index为字符表的哈希函数
class trie
{
public:
/* 定义类型别名 */
typedef trie_node<Size> node_type;
typedef trie_node<Size>* link_type;
/* 构造函数 */
trie(Index i = Index()) : index(i){ }
/* 析构函数 */
~trie() { clear(); }
/* 清空 */
void clear()
{
clear_node(root);
for (int i = 0; i < Size; ++i)
root.child[i] = 0;
}
/* 插入字符串 */
template <typename Iterator>
void insert(Iterator begin, Iterator end)
{
link_type cur = &root; //当前节点设置为根节点
for (; begin != end; ++begin)
{
if (!cur->child[index[*begin]]) //若当前字符找不到匹配，则新建节点
{
cur->child[index[*begin]] = new node_type;
++cur->node; //当前节点的子节点数加一
}
cur = cur->child[index[*begin]]; //将当前节点设置为当前字符对应的子节点
}
(cur->freq)++; //设置存放最后一个字符的节点的可终止标志为真
}
/* 插入字符串，针对C风格字符串的重载版本 */
void insert(const char *str)
{
insert(str, str + strlen(str));
}
/* 查找字符串，算法和插入类似 */
template <typename Iterator>
int getfreq(Iterator begin, Iterator end)
{
link_type cur = &root;
for (; begin != end; ++begin)
{
if (!cur->child[index[*begin]])
return false;
cur = cur->child[index[*begin]];
}
return cur->freq;
}
/* 查找字符串，针对C风格字符串的重载版本 */
bool find(const char *str)
{
int freq = getfreq(str, str + strlen(str));
return freq > 0;
}
/* 查找字符串str的词频*/
int getfreq(const char* str)
{
return getfreq(str,str + strlen(str));
}
/* 删除字符串 */
template <typename Iterator>
bool erase(Iterator begin, Iterator end)
{
bool result; //用于存放搜索结果
erase_node(begin, end, root, result);
return result;
}
/* 删除字符串，针对C风格字符串的重载版本 */
bool erase(const char *str)
{
return erase(str, str + strlen(str));
}
/* 按字典序遍历单词树的所有单词 */
template <typename Functor>
void traverse( Functor execute = Functor())
{
char word[100] = {0};
traverse_node(root, execute,word,0);
}
/*输出字典树单词的总个数，包含重复字符串*/
int sizeAll()
{
sizeAll(root);
}
int sizeAll(node_type& cur)
{
int size = cur.freq;
for(int i=0;i < Size; ++i)
{
if(cur.child[i] == 0)
continue;
size += sizeAll(*cur.child[i]);
}
return size;
}
/*输出字典树单词的总个数，重复字符串按一个处理*/
int sizeNoneRedundant()
{
sizeNoneRedundant(root);
}
int sizeNoneRedundant(node_type& cur)
{
int size = cur.freq>0?1:0;
for(int i=0;i < Size;++i)
{
if(cur.child[i] == 0)
continue;
size += sizeNoneRedundant(*cur.child[i]);
}
return size;
}
/*求字符串最长的公共前缀的长度*/
int maxPrefix_length()
{
int length = maxPrefix_length(root);
return length - 1; //因为length包含了根节点，需要删除。
}
int maxPrefix_length(node_type& cur)
{
int length = 0;
for(int i=0;i<Size;++i)
{
if(cur.child[i] != 0)
{
int tmp = maxPrefix_length(*cur.child[i]);
if(tmp > length)
{
length = tmp;
}
}
}
if(length > 0 || cur.node >1 || cur.freq >0 && cur.node>0) //cur.node >1 处理"abcde"与"abcdf"这种情况；cur.freq>0 && cur.node>0处理"abcde"与"abcdef"这种情况
{
length++;
}
return length;
}
/*求字符串最长的最共前缀*/
void maxPrefix(std::string& prefix)
{
maxPrefix(root,prefix);
std::string word(prefix);
int size = word.size();
for(int i=0;i<size;++i)
prefix[i] = word[size-1-i];
prefix.erase(size-1); //因为prefix包含了根节点字符，需要把它删除。
}
void maxPrefix(node_type& cur,std::string& prefix)
{
std::string word;
int length =0 ;
int k = 0;
for(int i=0;i<Size;++i)
{
if(cur.child[i] != 0)
{
maxPrefix(*cur.child[i],word);
if(word.size() > length)
{
length = word.size();
prefix.swap(word);
k = i;
}
}
}
if(length > 0 || cur.node >1 || cur.freq >0 && cur.node>0) //cur.node >1 处理"abcde"与"abcdf"这种情况；cur.freq>0 && cur.node>0处理"abcde"与"abcdef"这种情况
{
prefix.push_back(k + 'a');
}
}
private:
template<typename Functor>
void traverse_node(node_type& cur, Functor execute,char* word,int index)
{
if(cur.freq)
{
std::string str = word;
execute(str,cur.freq);
}
for(int i=0; i < Size; ++i)
{
if(cur.child[i] != 0)
{
word[index++] = 'a' + i;
traverse_node(*cur.child[i],execute,word,index);
word[index] = 0;
index--;
}
}
}
/* 清除某个节点的所有子节点 */
void clear_node(node_type& cur)
{
for (int i = 0; i < Size; ++i)
{
if (cur.child[i] == 0) continue;
clear_node(*cur.child[i]);
delete cur.child[i];
cur.child[i] = 0;
if (--cur.node == 0) break;
}
}
/* 边搜索边删除冗余节点，返回值用于向其父节点声明是否该删除该节点 */
template <typename Iterator>
bool erase_node(Iterator begin, Iterator end, node_type &cur, bool &result)
{
if (begin == end) //当到达字符串结尾：递归的终止条件
{
result = (cur.freq > 0); //如果当前节点的频率>0,则当前节点可以作为终止字符，那么结果为真
if(cur.freq)
cur.freq --; //如果当前节点为终止字符，词频减一
return cur.freq == 0 && cur.node == 0; //若该节点为树叶，那么通知其父节点删除它
}
//当无法匹配当前字符时，将结果设为假并返回假，即通知其父节点不要删除它
if (cur.child[index[*begin]] == 0) return result = false;
//判断是否应该删除该子节点
else if (erase_node((++begin)--, end, *(cur.child[index[*begin]]), result))
{
delete cur.child[index[*begin]]; //删除该子节点
cur.child[index[*begin]] = 0; //子节点数减一
//若当前节点为树叶，那么通知其父节点删除它
if (--cur.node == 0 && cur.freq == 0) return true;
}
return false; //其他情况都返回假
}
/* 根节点 */
node_type root;
/* 将字符转换为索引的转换表或函数对象 */
Index index;
};
//index function object
class IndexClass
{
public:
int operator[](const char key)
{
if(key>='a' && key <= 'z')
return key - 'a';
else if(key >= 'A' && key <= 'Z')
return key - 'A';
}
};
class StringExe
{
public:
void operator()(std::string& str,int freq)
{
std::cout<<str<<":"<<freq<<std::endl;
}
};
int main()
{
trie<26,IndexClass> t;
t.insert("tree");
t.insert("tree");
t.insert("tea");
t.insert("A");
t.insert("BABCDEGG");
t.insert("BABCDEFG");
t.traverse<StringExe>();
int sizeall = t.sizeAll();
std::cout<<"sizeAll:"<<sizeall<<std::endl;
int size = t.sizeNoneRedundant();
std::cout<<"size:"<<size<<std::endl;
std::string prefix;
int deep = t.maxPrefix_length();
t.maxPrefix(prefix);
std::cout<<"deep:"<<deep<<" prefix:"<<prefix<<std::endl;
if(t.find("tree"))
std::cout<<"find tree"<<std::endl;
else
std::cout<<"not find tree"<<std::endl;
int freq = t.getfreq("tree");
std::cout<<"tree freq:"<<freq<<std::endl;
if(t.erase("tree"))
std::cout<<"delete tree"<<std::endl;
else
std::cout<<"not find tree"<<std::endl;
freq = t.getfreq("tree");
std::cout<<"tree freq:"<<freq<<std::endl;
if(t.erase("tree"))
std::cout<<"delete tree"<<std::endl;
else
std::cout<<"not find tree"<<std::endl;
if(t.erase("tree"))
std::cout<<"delete tree"<<std::endl;
else
std::cout<<"not find tree"<<std::endl;
sizeall = t.sizeAll();
std::cout<<"sizeAll:"<<sizeall<<std::endl;
size = t.sizeNoneRedundant();
std::cout<<"size:"<<size<<std::endl;
if(t.find("tre"))
std::cout<<"find tre"<<std::endl;
else
std::cout<<"not find tre"<<std::endl;
t.traverse<StringExe>();
return 0;
}8. 其他代码实现
cppjieba使用trie存储字符串，它的实现代码位于https://github.com/yanyiwu/cppjieba/blob/master/src/Trie.hpp。这里由于要存储中文字符，孩子节点使用的是unordered_map。
9. 参考：
- 大部分代码来自于《Trie树的C++实现》
- 输出字符串代码参考《┎结构之美┒之Trie树》
- 计算字符串所有词频代码参考《Trie树（c++实现）》
