Ternary Search Tree Java实现

/**
 * @author Edwin Chen
 *
 */

//定义节点
class Node {
    //存储字符串
    char storeChar;
    //是否完成单词
    boolean isComplete;

    Node leftChild,centerChild,rightChild;

    //构造方法
    public Node(char storeChar,boolean isComplete) {
        this.storeChar = storeChar;
        this.isComplete = isComplete;
    }
}

public class TernarySearchTree {
    //根节点
    public Node root;

    //存储结果
    HashSet<String> result = new HashSet<String>();

    //递归创建tree
    public Node insert(String word,Node node,Integer index) {
        if(word == null || "".equals(word))
            return null;

        //将word转成char数组
        char[] charArray = word.toCharArray();

        //递归终止条件，当没有改字符时，创建新节点
        if(node == null) {
            node = new Node(charArray[index],false);
        }

        if(charArray[index] < node.storeChar) {
            node.leftChild = this.insert(word, node.leftChild,index);
        } else if(charArray[index] > node.storeChar) {
            node.rightChild = this.insert(word, node.rightChild,index);
        } else {
            //如果为word最后一个字符，那么设置为单词完结,如为最后一个字符，必定进入这一步
            if(index + 1 == charArray.length) {
                node.isComplete = true;
            } else {
                node.centerChild = this.insert(word, node.centerChild,++index);
            }
        }

        return node;
    }

    //封装
    public void insert(String word) {
        root = this.insert(word,root,0);
    }

    public String toString()
    {
        traverse(root, "");
        return "\nTernary Search Tree : "+ result;
    }
    
　　//遍历
    private void traverse(Node node, String str)
    {
        if (node != null)
        {
            traverse(node.leftChild, str);

            str = str + node.storeChar;
            if (node.isComplete)
                result.add(str);

            traverse(node.centerChild, str);
            str = str.substring(0, str.length() - 1);

            traverse(node.rightChild, str);
        }
    }

    public boolean search(String word)
    {
        return search(root, word.toCharArray(), 0);
    }

    private boolean search(Node node, char[] word, int index)
    {
        if (node == null)
            return false;

        if (word[index] < node.storeChar)
            return search(node.leftChild, word, index);
        else if (word[index] > node.storeChar)
            return search(node.rightChild, word, index);
        else
        {
            if (node.isComplete && index == word.length - 1)
                return true;
            else if (index == word.length - 1)
                return false;
            else
                return search(node.centerChild, word, index + 1);
        }
    }

    public Node findNode(String prefix) {
        return findNode(root,prefix.toCharArray(),0);
    }

    public Node findNode(Node node, char[] word, int index) {
        if (node == null)
            return null;

        if (word[index] < node.storeChar)
            return findNode(node.leftChild, word, index);
        else if (word[index] > node.storeChar)
            return findNode(node.rightChild, word, index);
        else
        {
            if (index == word.length - 1)
                return node.centerChild;
            else
                return findNode(node.centerChild, word, index + 1);
        }
    }

    //查找前缀相同的word
    public HashSet<String> prefixSearch(String prefix,Node node) {
        if(node != null) {
            if(node.isComplete) {
                result.add(prefix + node.storeChar);
            }

            prefixSearch(prefix,node.leftChild);
            prefixSearch(prefix + node.storeChar,node.centerChild);
            prefixSearch(prefix,node.rightChild);
        }

        if(search(prefix))
            result.add(prefix);

        return result;
    }

    public HashSet<String> prefixSearch(String prefix) {
        Node node = findNode(prefix);
        return prefixSearch(prefix,node);
    }

    public static void main(String[] args) {
        TernarySearchTree t = new TernarySearchTree();
        t.insert("ab");
        t.insert("abba");
        t.insert("abcd");
        t.insert("bcd");

        HashSet<String> a = t.prefixSearch("ab");
        for(String s : a) {
            System.out.println(s);
        }

        System.out.println(t);
    }
}