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);
}
}