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));// 2
        System.out.println(trie.wordCount(wd3));// 1
        System.out.println(trie.getTreeSize());// 4
        System.out.println();

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

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

        trie.deleteWord(wd2, 2);
        trie.deleteWord(wd2, 3);
        // wd1,wd3
        System.out.println(trie.wordCount(wd2));// 0
        System.out.println(trie.wordCount(wd3));// 1
        System.out.println(trie.getTreeSize());// 4
        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));// 0
        System.out.println(trie.wordCount(wd3));// 1
        System.out.println(trie.wordCount(wd4));// 0
        System.out.println(trie.getTreeSize());// 4
        System.out.println();

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

3、参考资料

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