Trie树的java实现

leetcode 地址：

https://leetcode.com/problems/implement-trie-prefix-tree/description/

难度：中等

描述：略

 

解题思路：

trie树 也就是字典查找树，是一种能够实现在一个字符串集中实现快速查找和匹配的多叉树结构，关于trie树的深入分析我就不展开了，因为我自己也理解的不深刻^_^，这里只给出trie树的定义，以及常用的应用场景，然后给出一个简单的java实现，当然代码简洁性和性能上有很大的优化空间。

首先，trie树的定义（或者说是性质）：

1. 根节点是一个空节点，不包含字符

2. 每个节点含有一个字符，以及若干个子节点

3. 每个节点的所有子节点所包含的字符都不相同

3. 树的每个节点到根节点的路径上的所有字符组成一个字符串，表示这个字符串在树中可能存在，或者至少trie树中存在以此字符串为前缀的字符串

4. 每个非根节点还应该包含一个整型数值，表示根节点到这个节点组成的字符串在trie树中出现的次数

 

trie数的常见应用场景：

1. 字符串检索

2. 词频统计

3. 前缀检索

4.前缀词频统计

5. 对所有的字符串按照字典序排序

 

java实现：

public class trie {
    public static void main(string[] args) {
        trie trie = new trie();
        trie.insert("apple");
        system.out.println(trie.search("apple"));
        system.out.println(trie.search("app"));     // returns false
        system.out.println(trie.startswith("app")); // returns true
        trie.insert("app");
        system.out.println(trie.search("app"));     // returns true
    }

    trienode root;

    /**
     * initialize your data structure here.
     */
    public trie() {
        root = new trienode();
    }

    /**
     * inserts a word into the trie.
     */
    public void insert(string word) {
        insert(word, root, 0);
    }

    /**
     * 将从index处开始的字串插入到root的子节点中，即将index对应的字符插入到root的子节点中
     * @param word
     * @param root
     * @param index
     */
    private void insert(string word, trienode root, int index) {
        assert index < word.length() && index > -1;
        char cur = word.charat(index);
        treemap<character, trienode> children = root.children;
        if (null == children) {
            children = new treemap<>();
            root.children = children;
        }
        if (!children.containskey(cur)) {
            children.put(cur, new trienode(cur));
        }
        if (index == word.length() - 1) {
            children.get(cur).occurency++;
            return;
        }
        insert(word, children.get(cur), index + 1);
    }

    /**
     * returns if the word is in the trie.
     */
    public boolean search(string word) {
        return search(word, root, 0);
    }

    /**
     * 在root的子节点中搜索从index开始的字串
     * @param word
     * @param root
     * @param index
     * @return
     */
    private boolean search(string word, trienode root, int index) {
        assert index > -1 && index < word.length();
        char cur = word.charat(index);
        if (root.children == null ||
                !root.children.containskey(cur)) {
            return false;
        }
        if (index == word.length() - 1) {
            return root.children.get(cur).occurency > 0;
        }
        return search(word, root.children.get(cur), index + 1);
    }

    /**
     * returns if there is any word in the trie that starts with the given prefix.
     */
    public boolean startswith(string prefix) {
        return startswith(prefix, root, 0);
    }

    /**
     * 在root的子节点中搜索从index开始字串对应的前缀
     * @param prefix
     * @param root
     * @param index
     * @return
     */
    private boolean startswith(string prefix, trienode root, int index) {
        assert index > -1 && index < prefix.length();
        char cur = prefix.charat(index);
        if (root.children == null ||
                !root.children.containskey(cur)) {
            return false;
        }
        if (index == prefix.length() - 1) {
            return true;
        }
        return startswith(prefix, root.children.get(cur), index + 1);
    }

    static class trienode {
        char c;
        int occurency = 0;
        treemap<character, trienode> children;

        public trienode() {
        }

        public trienode(char c) {
            this.c = c;
        }
    }
}