字典树

一、字典树

Trie树，即字典树，又称单词查找树或键树，是一种哈希树的变种。典型应用是用于统计和排序大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：最大限度地减少无谓的字符串比较，查询效率比哈希表高。
Trie的核心思想是空间换时间。利用字符串的公共前缀来降低查询时间的开销以达到提高效率的目的。
它有3个基本性质：

• 1）根节点不包含字符，除根节点外每一个节点都只包含一个字符。
• 2）从根节点到某一节点，路径上经过的字符连接起来，为该节点对应的字符串。
• 3）每个节点的所有子节点包含的字符都不相同。

根据字典树特性，和HasHMap比较，hashmap直接用哈希函数就能定位，但是trie树需要在子节点中比较，插入树的复杂程度要比HashMap高。但是，trie树对hashmap的优势是，在大量重复的单词中，trie树需要的内存会低一些。

具体的实现有：

public class TestMain2 {

    public static void main(String[] args) {
        TireBuilder builder = new TireBuilder();
        builder.addWord("chewi");
        builder.addWord("cew");
        builder.addWord("chi");
        builder.addWord("cki");

        List list = builder.getAllWordsByPrefix("ch");
        System.out.println(list);


    }


    private static class TireBuilder{

        private TireNode root;
        private Stack stack = new Stack<>();

        public void addWord(String s){
            if(root == null){
                root = new TireNode();
            }

            TireNode node = root;
            int len = 0;
            while (len < s.length()){
                node = node.nextNode(s.charAt(len));
                len++;
            }
            node.setString(s);
        }

        private void addNodeListToStack(ArrayList nodes) {
            nodes.forEach(t -> stack.push(t));
        }


        public ArrayList getAllWordsByPrefix(String prefix){
            int len = 0;
            TireNode node = root;
            while (len < prefix.length()){
                node = node.getNode(prefix.charAt(len));
                if(node == null){
                    break;
                }

                len++;
            }

            if (node == null) {
                return null;
            }


            addNodeListToStack(node.getAllNext());
            ArrayList allWords = new ArrayList<>();
            while (!stack.empty()) {
                TireNode n = stack.pop();
                if (!n.getString().isEmpty()) {
                    allWords.add(n.getString());
                }

                addNodeListToStack(n.getAllNext());
            }

            return allWords;

        }



    }


    private static class TireNode{
        private HashMap nodes = new HashMap<>();
        private String s = "";

        public String getString(){
            return s;
        }

        public void setString(String str){
            s = str;
        }

        public TireNode nextNode(Character b){
            if(nodes.get(b) == null){
                TireNode n = new TireNode();
                nodes.put(b, n);
            }
            return nodes.get(b);
        }

        public TireNode getNode(Character b){
            return nodes.get(b);
        }

        public ArrayList getAllNext(){
            ArrayList arr= new ArrayList<>();
            for(char c = 'a'; c<='z'; c++){
                if(nodes.get(c) != null){
                    arr.add(nodes.get(c));
                }
            }
            return arr;
        }

    }
}

参考来源：https://blog.csdn.net/xd_fybdw/article/details/81149742