字典树

package 字典树;

import java.util.LinkedList;

public class TrieNode {

	
	TrieNode preNode = null;
	int isEnd = 0;
	int deep = 0;
	char content = '0';
	LinkedList<TrieNode> child = new LinkedList<TrieNode>();

	TrieNode() {
		
	}
	
	public TrieNode(char content) {
		this.content = content;
	}
	
	public boolean equals(Object obj) {
		return (obj instanceof TrieNode) && ((TrieNode)obj).content == this.content;
	}
	
	public void setPreNode(TrieNode pre) {
		this.preNode = pre;
	}
	
	public TrieNode getPreNode() {
		return this.preNode;
	}
	
	public TrieNode getChildNode(char character) {
		for (TrieNode node : this.child) {
			if (node.content == character) {
				return node;
			}
		}
		return null;
	}
	
	public void removeChild(TrieNode node) {
		for (TrieNode achild : this.child) {
			if (achild.content == node.content) {
				this.child.remove(achild);
				break;
			}
		}
	}
	
}

public class TrieTree {
	private TrieNode root = new TrieNode();
	
	public void initTrieTree(String[] arrTrie) {
		
		for (int i = 0; i < arrTrie.length; i++) {
			this.addWord(arrTrie[i]);
		}
		
	}
	
	/**
	 * 添加word
	 * @param word
	 */
	public void addWord(String word) {
		int deep = 0;
		TrieNode currNode = this.root;
		while(deep < word.length()) {
			char c = word.charAt(deep);
			if (currNode.child.contains(new TrieNode(c))) {
				currNode = currNode.getChildNode(c);
			} else {
				TrieNode node = new TrieNode(c);
				node.setPreNode(currNode);
				node.deep += 1;
				currNode.child.add(node);
				currNode = node;
			}
			if (deep == word.length() - 1) {
				currNode.isEnd = 1;
			}
			deep++;
		}
	}
	
	public boolean hasWord(String word) {
		int deep = 0;
		TrieNode currNode = root;
		while(deep < word.length()) {
			char c = word.charAt(deep);
			if (currNode.child.contains(new TrieNode(c))) {
				currNode = currNode.getChildNode(c);
			} else {
				return false;
			}
			if (deep == word.length() - 1) {
				return currNode.isEnd == 1 ? true : false;
			}
			deep++;
		}
		return false;
	}
	
	public boolean removeWord(String word) {
		if (word == null || word.trim().equals("")) {
			return false;
		}
		
		if (hasWord(word)) {
			return false;
		}
		
		int deep = 0;
		TrieNode currNode = root;
		while(deep < word.length()) {
			char c = word.charAt(deep);
			if (currNode.child.contains(new TrieNode(c))) {
				currNode = currNode.getChildNode(c);
			} else {
				return false;
			}
			if (deep == word.length() - 1) {
				if (currNode.child.size() > 0) {
					currNode.isEnd = 0;
					return true;
				} else {
					TrieNode preNode = currNode.getPreNode();
//					preNode.removeChild(currNode);
					while(preNode != null) {
						if (preNode.child.size() == 0 && preNode.isEnd == 0) {
							preNode.removeChild(currNode);
							currNode = preNode;
						} else {
							return true;
						}
					}
				}
			}
			deep++;
		}
		return false;
	}
	
	

	
	//打印指定前缀的单词  
	public String hasPrefix(String prefix) {
		if (prefix == null || prefix.length() == 0) {
			return null;
		}
		TrieNode currNode = root;
		int deep = 0;
		while(deep < prefix.length()) {
			char c = prefix.charAt(deep);
			if (currNode.child.contains(new TrieNode(c))) {
				currNode = currNode.getChildNode(c);
			} else {
				return null;
			}
			if (deep == prefix.length() - 1) {
				preTraverse(currNode, prefix);
			}
		}
		
		return null;
	}
	
	//遍历经过此节点的单词
	public void preTraverse(TrieNode node, String prefix) {
		if (node.isEnd == 0) {
			for(TrieNode child : node.child) {
				if (child != null) {
					preTraverse(child, prefix + child.content);  
				}
			}
			return;
		}
		System.out.println(prefix);
	}
	
	//前序遍历
	private void preTraverse(TrieNode node) {
        if(node!=null) {
            System.out.print(node.content+"-");  
            for(TrieNode child : node.child) {  
                preTraverse(child);  
            }
        }
    }  
	
	public void preTraverse() {
		preTraverse(root);
	}

}