Trie tree实践

1、Trie树

Trie树即字典树或前缀树，

2、实践

代码实践如下：

 package cn.edu.buaa.trie;

 import java.util.HashSet;

 /**
  * @author zsm
  * @date 2016年10月25日 上午11:03:13
  * @version 1.0
  * @parameter
  * @return
  */
 public class Trie {
     private TrieNode trieRoot;
     private int treeSize;

     public Trie() {
         trieRoot = new TrieNode();
         treeSize = 0;
     }

     public TrieNode getRoot() {
         return trieRoot;
     }

     public int getTreeSize() {
         return treeSize;
     }

     /**
      * 添加单词
      */
     public void addWord(String word, int wordId) {
         addWord(trieRoot, word, wordId);
     }

     public void addWord(TrieNode root, String word, int wordId) {
         // 输入单词为空
         if (null == word || word.length() == 0) {
             return;
         }

         // 确定第一个字符在放在哪个孩子节点中
         int k = TrieNode.getCharPosition(word.charAt(0));

         // 该孩子为空，初始化
         if (root.childNodes[k] == null) {
             root.childNodes[k] = new TrieNode();
             treeSize++;
             root.childNodes[k].nodeChar = word.charAt(0);
         }
         // 单词出现在该孩子节点中
         root.childNodes[k].wordSet.add(wordId);

         word = word.substring(1);
         // 说明是最后一个字符，该词词频数加1
         if (word.length() == 0) {
             root.childNodes[k].freq++;
         } else {
             addWord(root.childNodes[k], word, wordId);
         }
     }

     /**
      * 删除单词
      */
     public void deleteWord(String word, int wordId) {
         deleteWord(trieRoot, word, wordId);
     }

     enum DELETERES {
         FAIL_EMPTYWORLD, FAIL_WORLD_NOT_EXIST, SUCCESS
     };

     public DELETERES deleteWord(TrieNode root, String word, int wordId) {
         // 输入单词为空
         if (null == word || word.length() == 0) {
             return DELETERES.FAIL_EMPTYWORLD;
         }

         int k = TrieNode.getCharPosition(word.charAt(0));

         // 第一个字符不在树中，说明没有要删除的单词
         if (root.childNodes[k] == null) {
             return DELETERES.FAIL_WORLD_NOT_EXIST;
         }

         // 第一个字符在树中
         DELETERES res;
         {
             word = word.substring(1);
             // 找到该单词
             if (word.length() == 0 && root.childNodes[k].freq > 0) {
                 root.childNodes[k].freq--;
                 res = DELETERES.SUCCESS;
             } else {
                 res = deleteWord(root.childNodes[k], word, wordId);
             }

             if (res == DELETERES.SUCCESS) {
                 // 从沿途节点移除该单词
                 root.childNodes[k].wordSet.remove(wordId);
                 // 没单词了，释放节点
                 if (root.childNodes[k].wordSet.size() == 0) {
                     root.childNodes[k] = null;
                     treeSize--;
                 }
             }
             return res;
         }
     }

     /**
      * 修改单词
      */
     public void updateWord(String newWord, String oldWord, int wordId) {
         updateWord(trieRoot, newWord, oldWord, wordId);
     }

     public void updateWord(TrieNode root, String newWord, String oldWord, int wordId) {
         if (deleteWord(root, oldWord, wordId) == DELETERES.SUCCESS) {
             addWord(root, newWord, wordId);
         }
     }

     /**
      * 找以给定单词为前缀的所有单词的id
      */
     public HashSet<Integer> searchPrefixWord(String word) {
         return searchPrefixWord(trieRoot, word);
     }

     public HashSet<Integer> searchPrefixWord(TrieNode root, String word) {

         HashSet<Integer> wordSet = new HashSet<Integer>();

         // 输入单词为空
         if (null == word || word.length() == 0) {
             return wordSet;
         }

         int k = TrieNode.getCharPosition(word.charAt(0));
         // 单词里某个字符在树种不存在，说明没有该单词
         if (root.childNodes[k] == null) {
             return wordSet;
         }

         word = word.substring(1);

         if (word.length() == 0) {
             wordSet = root.childNodes[k].wordSet;
         } else {
             wordSet = searchPrefixWord(root.childNodes[k], word);
         }
         return wordSet;
     }

     /**
      * 统计给定单词出现的次数
      */
     public int wordCount(String word) {
         return wordCount(trieRoot, word);
     }

     public int wordCount(TrieNode root, String word) {

         // 输入单词为空
         if (null == word || word.length() == 0) {
             return 0;
         }

         int k = TrieNode.getCharPosition(word.charAt(0));
         // 单词里某个字符在树种不存在，说明没有该单词
         if (root.childNodes[k] == null) {
             return 0;
         }

         int count = 0;
         word = word.substring(1);

         if (word.length() == 0) {
             count = root.childNodes[k].freq;
         } else {
             count = wordCount(root.childNodes[k], word);
         }

         return count;
     }
 }

 /**
  * Trie树的节点<br>
  * 假定单词都由26个英文字母组成，Trie树根节点不存字符
  */
 class TrieNode {
     // 孩子节点
     public TrieNode[] childNodes;
     // 该节点的字符
     public char nodeChar;

     // 以该节点为结束的单词的词频
     public int freq;
     // 包含该节点的单词的id
     public HashSet<Integer> wordSet;

     // 初始化
     public TrieNode() {
         childNodes = new TrieNode[CHILD_NUM];
         freq = 0;
         wordSet = new HashSet<Integer>();
     }

     private static final int CHILD_NUM = 26;

     public static int getCharPosition(char ch) {
         return (ch - 'a');
     }
 }

测试：

 package cn.edu.buaa.trie;

 /**
  * @author zsm
  * @date 2016年10月25日 下午3:12:02
  * @version 1.0
  * @parameter
  * @return
  */
 public class Main_Trie {

     public static void main(String[] args) {
         // TODO Auto-generated method stub
         Trie trie = new Trie();
         String wd1 = "ab";
         String wd2 = "ac";
         String wd3 = "acd";

         String wd4 = "add";

         trie.addWord(wd1, 1);
         trie.addWord(wd2, 2);
         trie.addWord(wd2, 3);
         trie.addWord(wd3, 4);

         // wd1,wd2,wd2,wd3
         System.out.println(trie.wordCount(wd2));//
         System.out.println(trie.wordCount(wd3));//
         System.out.println(trie.getTreeSize());//
         System.out.println();

         trie.deleteWord(wd3, 4);
         // wd1,wd2,wd2
         System.out.println(trie.wordCount(wd2));//
         System.out.println(trie.wordCount(wd3));//
         System.out.println(trie.getTreeSize());//
         System.out.println();

         trie.addWord(wd3, 4);
         // wd1,wd2,wd2,wd3
         System.out.println(trie.wordCount(wd2));//
         System.out.println(trie.wordCount(wd3));//
         System.out.println(trie.getTreeSize());//
         System.out.println();

         trie.deleteWord(wd2, 2);
         trie.deleteWord(wd2, 3);
         // wd1,wd3
         System.out.println(trie.wordCount(wd2));//
         System.out.println(trie.wordCount(wd3));//
         System.out.println(trie.getTreeSize());//
         System.out.println(trie.searchPrefixWord("a"));// [1,4]
         System.out.println();

         trie.updateWord(wd3, wd4, 4);
         // wd1,wd3
         System.out.println(trie.searchPrefixWord("a"));// [1,4]
         System.out.println(trie.wordCount(wd2));//
         System.out.println(trie.wordCount(wd3));//
         System.out.println(trie.wordCount(wd4));//
         System.out.println(trie.getTreeSize());//
         System.out.println();

         trie.updateWord(wd4, wd3, 4);
         // wd1,wd4
         System.out.println(trie.searchPrefixWord("a"));// [1,4]
         System.out.println(trie.wordCount(wd2));//
         System.out.println(trie.wordCount(wd3));//
         System.out.println(trie.wordCount(wd4));//
         System.out.println(trie.getTreeSize());//
         System.out.println();
     }
 }

3、参考资料

http://www.cnblogs.com/huangxincheng/archive/2012/11/25/2788268.html