1. Trie树
Trie树，即字典树，又称单词查找树或键树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计和排序大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：最大限度地减少无谓的字符串比较，查询效率比哈希表高。
Trie的核心思想是空间换时间。利用字符串的公共前缀来降低查询时间的开销以达到提高效率的目的。
它有3个基本性质：
- 根节点不包含字符，除根节点外每一个节点都只包含一个字符。
- 从根节点到某一节点，路径上经过的字符连接起来，为该节点对应的字符串。
- 每个节点的所有子节点包含的字符都不相同。
2. 字典树的构建
题目：给你100000个长度不超过10的单词。对于每一个单词，我们要判断他出没出现过，如果出现了，求第一次出现在第几个位置。
分析：这题当然可以用hash来解决，但是本文重点介绍的是trie树，因为在某些方面它的用途更大。比如说对于某一个单词，我们要询问它的前缀是否出现过。这样hash就不好搞了，而用trie还是很简单。
假设我要查询的单词是abcd，那么在他前面的单词中，以b，c，d，f之类开头的我显然不必考虑。而只要找以a开头的中是否存在abcd就可以了。同样的，在以a开头中的单词中，我们只要考虑以b作为第二个字母的，一次次缩小范围和提高针对性，这样一个树的模型就渐渐清晰了。
好比假设有b，abc，abd，bcd，abcd，efg，hii 这6个单词，我们构建的树就是如下图这样的：
分析：这题当然可以用hash来解决，但是本文重点介绍的是trie树，因为在某些方面它的用途更大。比如说对于某一个单词，我们要询问它的前缀是否出现过。这样hash就不好搞了，而用trie还是很简单。
假设我要查询的单词是abcd，那么在他前面的单词中，以b，c，d，f之类开头的我显然不必考虑。而只要找以a开头的中是否存在abcd就可以了。同样的，在以a开头中的单词中，我们只要考虑以b作为第二个字母的，一次次缩小范围和提高针对性，这样一个树的模型就渐渐清晰了。
好比假设有b，abc，abd，bcd，abcd，efg，hii 这6个单词，我们构建的树就是如下图这样的：
ok，如上图所示，对于每一个节点，从根遍历到他的过程就是一个单词，如果这个节点被标记为红色，就表示这个单词存在，否则不存在。
那么，对于一个单词，我只要顺着他从根走到对应的节点，再看这个节点是否被标记为红色就可以知道它是否出现过了。把这个节点标记为红色，就相当于插入了这个单词。
这样一来我们查询和插入可以一起完成（重点体会这个查询和插入是如何一起完成的，稍后，下文具体解释），所用时间仅仅为单词长度，在这一个样例，便是10。
我们可以看到，trie树每一层的节点数是26^i级别的。所以为了节省空间。我们用动态链表，或者用数组来模拟动态。空间的花费，不会超过单词数×单词长度。
那么，对于一个单词，我只要顺着他从根走到对应的节点，再看这个节点是否被标记为红色就可以知道它是否出现过了。把这个节点标记为红色，就相当于插入了这个单词。
这样一来我们查询和插入可以一起完成（重点体会这个查询和插入是如何一起完成的，稍后，下文具体解释），所用时间仅仅为单词长度，在这一个样例，便是10。
我们可以看到，trie树每一层的节点数是26^i级别的。所以为了节省空间。我们用动态链表，或者用数组来模拟动态。空间的花费，不会超过单词数×单词长度。
已知n个由小写字母构成的平均长度为10的单词,判断其中是否存在某个串为另一个串的前缀子串。下面对比3种方法：
- 最容易想到的：即从字符串集中从头往后搜，看每个字符串是否为字符串集中某个字符串的前缀，复杂度为O(n^2)。
- 使用hash：我们用hash存下所有字符串的所有的前缀子串，建立存有子串hash的复杂度为O(n*len)，而查询的复杂度为O(n)* O(1)= O(n)。
- 使用trie：因为当查询如字符串abc是否为某个字符串的前缀时，显然以b,c,d....等不是以a开头的字符串就不用查找了。所以建立trie的复杂度为O(n*len)，而建立+查询在trie中是可以同时执行的，建立的过程也就可以成为查询的过程，hash就不能实现这个功能。所以总的复杂度为O(n*len)，实际查询的复杂度也只是O(len)。（说白了，就是Trie树的平均高度h为len，所以Trie树的查询复杂度为O（h）=O（len）。好比一棵二叉平衡树的高度为logN，则其查询，插入的平均时间复杂度亦为O（logN））。
3. 查询
Trie树是简单但实用的数据结构，通常用于实现字典查询。我们做即时响应用户输入的AJAX搜索框时，就是Trie开始。本质上，Trie是一颗存储多个字符串的树。相邻节点间的边代表一个字符，这样树的每条分支代表一则子串，而树的叶节点则代表完整的字符串。和普通树不同的地方是，相同的字符串前缀共享同一条分支。下面，再举一个例子。给出一组单词，inn, int, at, age, adv, ant, 我们可以得到下面的Trie：
可以看出：
- 每条边对应一个字母。
- 每个节点对应一项前缀。叶节点对应最长前缀，即单词本身。
- 单词inn与单词int有共同的前缀“in”, 因此他们共享左边的一条分支，root->i->in。同理，ate, age, adv, 和ant共享前缀"a"，所以他们共享从根节点到节点"a"的边。
查询操纵非常简单。比如要查找int，顺着路径i -> in -> int就找到了。
搭建Trie的基本算法也很简单，无非是逐一把每则单词的每个字母插入Trie。插入前先看前缀是否存在。如果存在，就共享，否则创建对应的节点和边。比如要插入单词add，就有下面几步：
- 考察前缀"a"，发现边a已经存在。于是顺着边a走到节点a。
- 考察剩下的字符串"dd"的前缀"d"，发现从节点a出发，已经有边d存在。于是顺着边d走到节点ad
- 考察最后一个字符"d"，这下从节点ad出发没有边d了，于是创建节点ad的子节点add，并把边ad->add标记为d。
4. 应用
- 1、有一个1G大小的一个文件，里面每一行是一个词，词的大小不超过16字节，内存限制大小是1M。返回频数最高的100个词。
- 2、1000万字符串，其中有些是重复的，需要把重复的全部去掉，保留没有重复的字符串。请怎么设计和实现？
- 3、 一个文本文件，大约有一万行，每行一个词，要求统计出其中最频繁出现的前10个词，请给出思想，给出时间复杂度分析。
- 4、寻找热门查询：搜索引擎会通过日志文件把用户每次检索使用的所有检索串都记录下来，每个查询串的长度为1-255字节。假设目前有一千万个记录，这些查询串的重复读比较高，虽然总数是1千万，但是如果去除重复和，不超过3百万个。一个查询串的重复度越高，说明查询它的用户越多，也就越热门。请你统计最热门的10个查询串，要求使用的内存不能超过1G。
- (1) 请描述你解决这个问题的思路；
- (2) 请给出主要的处理流程，算法，以及算法的复杂度。
5. 代码实现
package cn.com.bestv.search.util;
import java.util.ArrayList;
import java.util.List;
/**
* code by me
* <p>
* Data:2017/8/15 Time:17:18
* User:lbh
*/
public class Trie {
private static final int SIZE = 26;
private TreeNode root; // 根节点
private class TreeNode { // 节点
private int num;
private TreeNode[] children;
private char val;
private boolean isLast;
private TreeNode() {
num = 1;
children = new TreeNode[SIZE];
isLast = false;
}
}
Trie() {
root = new TreeNode();
root.val = '*';
}
/**
* 构建
*
* @param str
*/
private void insert(String str) {
if (str == null || str == "") {
return;
}
char[] chars = str.toCharArray();
TreeNode node = root;
for (int i = 0; i < chars.length; i++) {
int pos = chars[i] - 'a';
if (node.children[pos] == null) {
node.children[pos] = new TreeNode();
node.children[pos].val = chars[i];
} else {
node.children[pos].num++;
}
node = node.children[pos];
}
node.isLast = true;
}
/**
* 前序遍历 根-左-右
*
* @param treeNode
*/
private void preOrder(TreeNode treeNode, List<String> res) {
if (treeNode == null) {
return;
}
for (TreeNode node : treeNode.children) {
if (node != null) {
res.add(Character.toString(node.val));
preOrder(node, res);
}
}
}
/**
* 前序遍历
*
* @param treeNode
* @return
*/
private List<String> traverse(TreeNode treeNode) {
List<String> resList = new ArrayList<>();
this.preOrder(treeNode, resList);
return resList;
}
/**
* 全匹配
*
* @param str
* @return
*/
private boolean has(String str) {
TreeNode node = root;
char[] chars = str.toCharArray();
for (int i = 0; i < chars.length; i++) {
int pos = chars[i] - 'a';
if (node.children[pos] != null) {
node = node.children[pos];
} else {
return false;
}
}
return true;
}
/**
* 找指定前缀
*
* @param prefix
* @return
*/
private List<String> hasPrefix(String prefix) {
if (prefix == null || "".equals(prefix)) {
return null;
}
List<String> resList = new ArrayList<>();
TreeNode node = root;
char[] chars = prefix.toCharArray();
for (int i = 0; i < chars.length; i++) {
int pos = chars[i] - 'a';
if (node.children[pos] != null) {
node = node.children[pos];
} else {
return null;
}
}
preTraverse(node, prefix, resList);
return resList;
}
private void preTraverse(TreeNode node, String prefix, List<String> resList) {
for (TreeNode childrenNode : node.children) {
if (childrenNode != null) {
preTraverse(childrenNode, prefix + childrenNode.val, resList);
}
}
if (node.isLast) {
resList.add(prefix);
}
return;
}
/**
* 前缀单词的数量
*
* @param prefix
* @return
*/
private int preCountPrefix(String prefix) {
if (prefix == null || "".equals(prefix)) {
return 0;
}
char[] chars = prefix.toCharArray();
TreeNode node = root;
for (int i = 0; i < chars.length; i++) {
int pos = chars[i] - 'a';
if (node.children[pos] != null) {
node = node.children[pos];
} else {
return 0;
}
}
return node.num;
}
public static void main(String[] args) {
Trie trie = new Trie();
String[] strings = {"liubaohua", "baohua", "liubao", "hua", "abc", "bestv",};
for (String str : strings) {
trie.insert(str);
}
System.out.println(trie.traverse(trie.root));
System.out.println(trie.has("abc"));
System.out.println(trie.hasPrefix("liu"));
System.out.println(trie.preCountPrefix("liu"));
}
}