一、前缀树介绍

（注：本节内容来源于网络）

定义： 

所有含有公共前缀的字符串将挂在树中同一个结点下。实际上trie简明的存储了存在于串集合中的所有公共前缀。

假如有这样一个字符串集合X{bear,bell,bid,bull,buy,sell,stock,stop}。它的标准Trie树如下图：

      如上图（蓝色圆形结点为内部结点，红色方形结点为外部结点），我们可以很清楚的看到字符串集合X构造的Trie树结构。其中从根结点到红色方框叶子节点所经历的所有字符组成的串就是字符串集合X中的一个串。

      注意这里有一个问题： 如果X集合中有一个串是另一个串的前缀呢？ 比如，X集合中加入串bi。那么上图的Trie树在绿色箭头所指的内部结点i 就应该也标记成红色方形结点。这样话，一棵树的枝干上将出现两个连续的叶子结点(这是不合常理的)。

      也就是说字符串集合X中不存在一个串是另外一个串的前缀 。如何满足这个要求呢？我们可以在X中的每个串后面加入一个特殊字符$(这个字符将不会出现在字母表中)。这样，集合X{bear$、bell$、…. bi$、bid$}一定会满足这个要求。

      总结：一个存储长度为n，来自大小为d的字母表中s个串的集合X的标准trie具有性质如下：

      (1) 树中每个内部结点至多有d个子结点。

      (2) 树有s个外部结点。

      (3) 树的高度等于X中最长串的长度。

      (4) 树中的结点数为O(n)。

标准 Trie树的查找：

       对于英文单词的查找，我们完全可以在内部结点中建立26个元素组成的指针数组。如果要查找a，只需要在内部节点的指针数组中找第0个指针即可(b=第1个指针，随机定位)。时间复杂度为O(1)。

      查找过程：假如我们要在上面那棵Trie中查找字符串bull (b-u-l-l)。

      (1) 在root结点中查找第(‘b’-‘a’=1)号孩子指针，发现该指针不为空，则定位到第1号孩子结点处——b结点。

      (2) 在b结点中查找第(‘u’-‘a’=20)号孩子指针，发现该指针不为空，则定位到第20号孩子结点处——u结点。

      (3) … 一直查找到叶子结点出现特殊字符‘$’位置，表示找到了bull字符串

      如果在查找过程中终止于内部结点，则表示没有找到待查找字符串。

 效率：

对于有n个英文字母的串来说，在内部结点中定位指针所需要花费O(d)时间，d为字母表的大小，英文为26。由于在上面的算法中内部结点指针定位使用了数组随机存储方式，因此时间复杂度降为了O(1)。但是如果是中文字，下面在实际应用中会提到。因此我们在这里还是用O(d)。 查找成功的时候恰好走了一条从根结点到叶子结点的路径。因此时间复杂度为O(d*n)。

      但是，当查找集合X中所有字符串两两都不共享前缀时，trie中出现最坏情况。除根之外，所有内部结点都自由一个子结点。此时的查找时间复杂度蜕化为O(d*(n^2))

二、前缀树的java实现

在算法中使用了java的map集合对象来构造树结构，使用map有如下优缺点：

优点：实现简单，操作简单

缺点：比较浪费内存空间。因为map对象在初始化时默认会分配16个entry空间，map对象有一个加载因子（load factor），加载因子的默认值是0.75，其意思是说当分配给map对象的内存空间占用率达到3/4时，map对象的内存空间会翻倍。例如分配给map对象的内存空间为16个entry，当内存空间占用达到12个entry时，map对象的内存空间就会变为32个entry。因此，map的这种机制在某些情况下会严重占用内存空间。可以增加加载因子来节省内存空间，但是这样会导致map的hash空间变小，那么hash时冲突就会增加，最后会影响到搜索的效率。因此，要根据具体的情况来选择合适的加载因子，以平衡空间利用率和效率。

打算做一个比较通用的字典树程序包，初步打算实现三种比较常用的trie树：前缀树、压缩树、后缀树。

设计类图如下所示：

（目前只初步实现了前缀树）

其代码如下所示：

[java] 
view plain
copy
print
?

1. package org.trie;  
2.   
3. public interface Trie {  
4.       
5.       
6.     public void build(String dictName);  
7.       
8.       
9.     public boolean search(String word);  
10.       
11.       
12.     public boolean insert(String word);  
13.       
14.       
15.     public boolean delete(String word);  
16.       
17.       
18.     public void save(String path);  
19.       
20.       
21.     public void read(String path);  
22. }  

[java] 
view plain
copy
print
?

1. package org.trie.prefix;  
2. import java.util.Map;  
3.   
4. public class Node {  
5.     private char c; //    
6.     private int type; //    
7.     private Map children; //   
8.     public Node() {  
9.         this.c = ‘ ‘;  
10.         this.type = –1;  
11.         this.children = null;  
12.     }  
13.     public char getC() {  
14.         return c;  
15.     }  
16.     public void setC(char c) {  
17.         this.c = c;  
18.     }  
19.     public int getType() {  
20.         return type;  
21.     }  
22.     public void setType(int type) {  
23.         this.type = type;  
24.     }  
25.     public void addChild(char c, Node child) {  
26.         children.put(c + “”, child);  
27.     }  
28.     public Map getChildren() {  
29.         return children;  
30.     }  
31.     public void setChildren(Map children) {  
32.         this.children = children;  
33.     }  
34.     public boolean contains(char c) {  
35.         if (children.containsKey(c + “”)) {  
36.             return true;  
37.         }  
38.         return false;  
39.     }  
40.     public Node next(char c) {  
41.         return children.get(c + “”);  
42.     }  
43.     public int sizeOfChildren() {  
44.         return children.size();  
45.     }  
46.     public void removeChild(char c) {  
47.         children.remove(c + “”);  
48.     }  
49. }  

children; // public Node() { this.c = ‘ ‘; this.type = -1; this.children = null; } public char getC() { return c; } public void setC(char c) { this.c = c; } public int getType() { return type; } public void setType(int type) { this.type = type; } public void addChild(char c, Node child) { children.put(c + “”, child); } public Map getChildren() { return children; } public void setChildren(Map children) { this.children = children; } public boolean contains(char c) { if (children.containsKey(c + “”)) { return true; } return false; } public Node next(char c) { return children.get(c + “”); } public int sizeOfChildren() { return children.size(); } public void removeChild(char c) { children.remove(c + “”); } }  

[java] 
view plain
copy
print
?

1. package org.trie.prefix;  
2. import java.util.HashMap;  
3.   
4. public class BranchNode extends Node {  
5.     public BranchNode(char c) {  
6.         super.setC(c);  
7.         super.setType(1);  
8.         super.setChildren(new HashMap());  
9.     }  
10. }  

()); } }  

[java] 
view plain
copy
print
?

1. package org.trie.prefix;  
2.   
3. public class LeafNode extends Node {  
4.     public LeafNode() {  
5.         super.setC(‘

   
   

   );  

6.         super.setType(1);  
7.     }  
8. }  

); super.setType(1); } }  

[java] 
view plain
copy
print
?

1. package org.trie.prefix;  
2. import java.io.BufferedReader;  
3. import java.io.File;  
4. import java.io.FileReader;  
5. import org.trie.Trie;  
6.   
7. public class PrefixTrie implements Trie {  
8.     private Node root;  
9.     public PrefixTrie() {  
10.         root = new BranchNode(‘ ‘);  
11.     }  
12.     public void build(String dictName) {  
13.         BufferedReader reader = null;  
14.         int i = 0;  
15.         try {  
16.             reader = new BufferedReader(new FileReader(new File(dictName)));  
17.             String word = reader.readLine();  
18.             while (word != null && !word.trim().equals(“”)) {  
19.                 i++;  
20.                 word += “$”;  
21.                 insert(word);  
22.                 word = reader.readLine();  
23.             }  
24.             System.out.println(“total words: “ + i);  
25.         } catch (Exception e) {  
26.             e.printStackTrace();  
27.         } finally {  
28.             if (reader != null) {  
29.                 try {  
30.                     reader.close();  
31.                 } catch (Exception e) {  
32.                     e.printStackTrace();  
33.                 }  
34.             }  
35.         }  
36.     }  
37.     public boolean insert(String word) {  
38.         if (search(word)) {  
39.             System.out.println(“The word has already been added into the trie!”);  
40.             return false;  
41.         } else {  
42.             char[] chars = word.toCharArray();  
43.             Node currentNode = root;  
44.             char c;  
45.             for (int i = 0; i < chars.length; i++) {  
46.                 c = chars[i];  
47.                 if (c == ‘

    ) {  

48.                     Node leaf = new LeafNode();  
49.                     currentNode.addChild(‘

    , leaf);  

50.                 }else{  
51.                     if (currentNode.contains(c)) {  
52.                         currentNode = currentNode.next(c);  
53.                     } else {  
54.                         Node branch = new BranchNode(c);  
55.                         currentNode.addChild(c, branch);  
56.                         currentNode = branch;  
57.                     }  
58.                 }  
59.             }  
60.             return true;  
61.         }  
62.     }  
63.     public boolean delete(String word) {  
64.         if(!search(word)){  
65.             System.out.println(“No such word exists in the trie!”);  
66.             return false;  
67.         }else {  
68.             char[] chars = word.toCharArray();  
69.             Node formerNode = root;  
70.             Node currentNode = root;  
71.             char c;  
72.             for (int i = 0; i < chars.length; i++) {  
73.                 c = chars[i];  
74.                 if (currentNode.sizeOfChildren() == 1) {  
75.                     formerNode.removeChild(currentNode.getC());  
76.                 }else if (c == ‘

    ) {  

77.                     currentNode.removeChild(c);  
78.                 }else {  
79.                     formerNode = currentNode;  
80.                     currentNode = currentNode.next(c);  
81.                 }  
82.             }  
83.             return true;  
84.         }  
85.     }  
86.     public boolean search(String word) {  
87.         char[] chars = word.toCharArray();  
88.         Node currentNode = root;  
89.         char c;  
90.         for (int i = 0; i < chars.length; i++) {  
91.             c = chars[i];  
92.             if (c == ‘

     && currentNode.contains(c)) {  

93.                 return true;  
94.             }else {  
95.                 if (currentNode.contains(c)) {  
96.                     currentNode = currentNode.next(c);  
97.                 } else {  
98.                     return false;  
99.                 }  
100.             }  
101.         }  
102.         return false;  
103.     }  
104.     public void read(String path) {  
105.     }  
106.     public void save(String path) {  
107.     }  
108. }  

) { Node leaf = new LeafNode(); currentNode.addChild(‘, leaf); }else{ if (currentNode.contains(c)) { currentNode = currentNode.next(c); } else { Node branch = new BranchNode(c); currentNode.addChild(c, branch); currentNode = branch; } } } return true; } } public boolean delete(String word) { if(!search(word)){ System.out.println(“No such word exists in the trie!”); return false; }else { char[] chars = word.toCharArray(); Node formerNode = root; Node currentNode = root; char c; for (int i = 0; i < chars.length; i++) { c = chars[i]; if (currentNode.sizeOfChildren() == 1) { formerNode.removeChild(currentNode.getC()); }else if (c == ‘) { currentNode.removeChild(c); }else { formerNode = currentNode; currentNode = currentNode.next(c); } } return true; } } public boolean search(String word) { char[] chars = word.toCharArray(); Node currentNode = root; char c; for (int i = 0; i < chars.length; i++) { c = chars[i]; if (c == ‘&& currentNode.contains(c)) { return true; }else { if (currentNode.contains(c)) { currentNode = currentNode.next(c); } else { return false; } } } return false; } public void read(String path) { } public void save(String path) { } }  

[java] 
view plain
copy
print
?

1. package org.trie.test;  
2. import java.io.File;  
3. import org.trie.Trie;  
4. import org.trie.prefix.PrefixTrie;  
5.   
6. public class PrefixTrieTest {  
7.     public static void main(String[] args) {  
8.         String path = new File(“”).getAbsolutePath() + File.separator + “dict//CoreDict.txt”;  
9.         Trie trie = new PrefixTrie();  
10.         trie.build(path);  
11.         System.out.println(trie.search(“中华人民共和国$”));  
12.         System.out.println(trie.delete(“中国$”));  
13.         System.out.println(trie.search(“中国人$”));  
14.         System.out.println(trie.search(“中$”));  
15.         System.out.println(trie.search(“中国$”));  
16.     }  
17. }  

测试结果是正确的，但是可能没测试完全。

接口中有两个方法save和read暂时还没有想到怎么去实现，还有待研究。

三、算法可以改进的地方

初步实现的算法将每个单词的每个字符都存在了一个结点中，这无疑会非常浪费存储空间。

改进的方法：

可以将没有分支的单词后缀作为字符串存储在叶节点中，另如一个单词abcdefg$，如果在字符‘c’处分支后，后面没有其它单词与它拥有共同的前缀，那么就可以将“defg$”作为一个符串存在叶节点中。当插入一个单词abcdemn$时，可以将公共的de两个字符分出来分别存在分支结点中。

当然如果像这样改进，程序的数据结构及算法要做出相应的改变。