trie树的实现和应用及测试

测试输出为:

按字典顺序输出trie树中所有的字符串 递归实现：
 abc
 abc
 abcd
 aca
 adac
 ava
 bda
按字典顺序输出trie树中所有的字符串 迭代实现：
 abc
 abc
 abcd
 aca
 adac
 ava
 bda
是否出现字符串ava：true
前缀a出现的次数:6
输出还有前缀的ab的所有字符串：
abc
abc
abcd


Process finished with exit code 0

java代码如下：

package com.liyiwen.TestTrie;

import javax.swing.tree.TreeNode;
import java.util.Stack;

/**
 * @author liyiwen1
 * @date 2016/12/5
 */
//trie树可以以非常少的，存储大量具有很多相同前缀的字符串。trie树查询比哈希表快，
public class Trie {
    public static void main(String[] args) {
        String[] strings = new String[]{"ava", "aca", "bda", "adac", "abc","abcd", "abc"};
        Trie trie = Trie.getInstance();
        for (String string : strings){
            trie.insert(string);
        }
        System.out.println("按字典顺序输出trie树中所有的字符串 递归实现：");
        trie.printAllString();
        System.out.println("按字典顺序输出trie树中所有的字符串 迭代实现：");
        trie.printAllStringIteration();
        System.out.println("是否出现字符串ava：" + trie.hasString("ava"));
        System.out.println("前缀a出现的次数:" + trie.preCount("a"));
        System.out.println("输出还有前缀的ab的所有字符串：");
        trie.printAllStrsContainsPre("ab");

    }
    private int size = 26;
    private TrieNode root;

    private Trie() {
        root = new TrieNode();
    }

    public static Trie getInstance() {
        return new Trie();
    }

    public void insert(String str) {
        if (null == str || str.isEmpty()) {
            return;
        }
        TrieNode node = root;
        char[] charArray = str.toCharArray();
        for (char val : charArray) {
            int index = val - 'a';
            if (null == node.nodes[index]) {
                node.nodes[index] = new TrieNode();
                node.nodes[index].val = val;
            } else {
                node.nodes[index].passCount++;
            }
            node = node.nodes[index];
        }
        node.isEnd++;
    }

    //判断是否出现字符串extStr
    public boolean hasString(String extStr) {
        if (null == extStr || extStr.isEmpty()) return false;
        char[] chars = extStr.toCharArray();
        TrieNode node = root;
        for (char val : chars) {
            int index = val - 'a';
            if (null == node.nodes[index]) {
                return false;
            } else {
                node = node.nodes[index];
            }
        }
        return node.isEnd != 0;
    }

    //计算前缀出现的次数
    public int preCount(String pex) {
        if (null == pex || pex.isEmpty()) return 0;
        TrieNode node = root;
        char[] chars = pex.toCharArray();
        for (char val : chars) {
            int index = val - 'a';
            if (null == node.nodes[index]) {
                return 0;
            } else {
                node = node.nodes[index];
            }
        }
        return node.passCount;
    }

    //输出所有的字符串,按字典顺序
    public void printAllString(){
        printAllString(getRoot(), "");
    }

    //输出所有的字符串,按字典顺序, 迭代实现
    public void printAllStringIteration(){
        printAllStringIteration(getRoot(), "");
    }


    //输入以node为根节点的树所包含的所有字符串，pre为前缀
    private void printAllString(TrieNode node, String pre){
        if (node == null){
            return ;
        }
        pre = pre + node.val;
        if (node.isEnd != 0){
            for (int i = 0; i < node.isEnd; i++){
                System.out.println(pre);
            }
        }
        for (TrieNode node1 : node.nodes){
            printAllString(node1, pre);
        }
    }

    private static class Pair{
        private TrieNode node;
        private String pre;

        public TrieNode getNode() {
            return node;
        }

        public void setNode(TrieNode node) {
            this.node = node;
        }

        public String getPre() {
            return pre;
        }

        public void setPre(String pre) {
            this.pre = pre;
        }

        public Pair(TrieNode node, String pre) {
            this.node = node;
            this.pre = pre;
        }
    }

    //输出含有pre前缀的所有字符串
    public void printAllStrsContainsPre(String pre){
        TrieNode node = getRoot();
        for (char c : pre.toCharArray()){
            int index = c - 'a';
            if (node.nodes[index] == null){
                return;
            }else{
                node = node.nodes[index];
            }
        }
        for (TrieNode node1 : node.nodes){
            if (node1  != null){
                printAllString(node1, pre);
            }
        }

    }

    //输入以node为根节点的树所包含的所有字符串，pre为前缀， 迭代实现
    private void printAllStringIteration(TrieNode node, String pre){
        Stack<Pair> stack = new Stack<Pair>();
        stack.push(new Pair(node, pre));
        while (!stack.isEmpty()){
            Pair pair = stack.pop();
            node = pair.node;
            pre = pair.pre;
            if (node != null){
                pre = pre + node.val;
                if (node.isEnd != 0){
                    for (int i = 0; i < node.isEnd; i++){
                        System.out.println(pre);
                    }
                }
                for (int i = node.nodes.length - 1; i >= 0; i--){
                    stack.push(new Pair(node.nodes[i], pre));
                }
            }
        }

    }

    //前序遍历Trie树
    public void preOrderTraverse() {
        preOrderTraverse(getRoot());
    }

    private void preOrderTraverse(TrieNode node) {
        if (node != null) {
            System.out.print(node.val + "-");
            for (TrieNode sonNode : node.nodes) {
                preOrderTraverse(sonNode);
            }
        }
    }



    private TrieNode getRoot() {
        return root;
    }

    private class TrieNode {
        private int passCount;
        private int isEnd;
        private TrieNode[] nodes;
        private char val;

        public TrieNode() {
            passCount = 1;
            isEnd = 0;
            nodes = new TrieNode[size];
        }
    }
}