Trie

package com.trie.base.bean;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

public class TrieNode implements Comparable<TrieNode>{

	/**
	 * 节点的key
	 * 
	 */
	protected int key;

	/**
	 *节点对应的字符串 
	 */
	protected String word;

	/**
	 * 节点的前缀节点
	 */
	protected TrieNode fatherNode;

	/**
	 * 以该节点作为前缀的子节点
	 */
	protected List<TrieNode> childNodes;

	/**
	 * 在list的index和char的int值之间建立映射
	 */
	protected Map<Integer,Integer> indexMap;

	/**
	 * 搜索次数
	 */
	protected int click=0;

	protected Object obj;

	public List<TrieNode> getChildNodes() {

		if(null==childNodes){
			childNodes=new ArrayList<TrieNode>();
			indexMap =new HashMap<Integer, Integer>();
		}

		return childNodes;
	}

	public void setChildNodes(List<TrieNode> childNodes) {
		this.childNodes = childNodes;
	}

	public TrieNode getFatherNode() {
		return fatherNode;
	}

	public void setFatherNode(TrieNode fatherNode) {
		this.fatherNode = fatherNode;
	}

	public String getWord() {
		return word;
	}

	public void setWord(String word) {
		this.word = word;
	}

	/**
	 * @param key
	 */
	public TrieNode(int key,String word) {
		super();
		this.key = key;
		this.word=word;
	} 

	/**
	 * @param key
	 */
	public TrieNode() {
		super();
	} 

	public boolean add(TrieNode childNode){

		childNode.setFatherNode(this);
		getChildNodes().add(childNode);
		getIndexMap().put(childNode.getKey(),getChildNodes().size());

		return true;
	}

	public TrieNode get(char c){
		return get((int)c);
	}

	public TrieNode get(int c){
		Integer o=getIndexMap().get(c);
		if(null==o){
			return null;
		}

 		return getChildNodes().get(o-1);
	}

	public TrieNode addClick(){
		this.click++;
		return this;
	}

	public Map<Integer, Integer> getIndexMap() {
		if(null==indexMap){
			indexMap=new HashMap<Integer, Integer>();
		}
		return indexMap;
	}

	public void setIndexMap(Map<Integer, Integer> indexMap) {
		this.indexMap = indexMap;
	}


	public int getClick() {
		return click;
	}

	public void setClick(int click) {
		this.click = click;
	}

	public int getKey() {
		return key;
	}

	public void setKey(int key) {
		this.key = key;
	}

	public List<TrieNode> getAllChild(){
		List<TrieNode> list = new ArrayList<TrieNode>();
		for(Iterator<TrieNode> it=getChildNodes().iterator();it.hasNext();){
			TrieNode node=it.next();
			list.add(node);
			if(node.getChildNodes().size()>0){
				list.addAll(node.getAllChild());
			}
		}
		return list;
	}

	public int compareTo(TrieNode o) {
		if(null==o||o.getClick()<this.click){
			return -1;	
		}else if(o.getClick()==this.click){
			return 0;
		}else{
			return 1;
		}
	}

	public Object getObj() {
		return obj;
	}

	public void setObj(Object obj) {
		if(obj==null){
			return;
		}
		this.obj = obj;
	}

}

package com.trie.base;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import com.trie.base.bean.TrieNode;

public class Trie  {

	//该字符树所有节点的数量
	protected int entityTrieNodeSize=0;

	//该字符树所有节点的数量
	protected int trieNodeSize=0;

	//第一层Node
	protected TrieNode firstLvNode;

	//禁用词
	protected Set<String> filterWords;	

	//搜索链表
	protected List<TrieNode> entityNodes;

	/**
	 * 插入节点
	 */
	public TrieNode insert(String word,Object obj){

		if(filter(word)){
			return null;
		};		

		char[] words=word.toCharArray();

		TrieNode temp=null;
		TrieNode tempFather=null;

		for(int i=0;i<words.length;i++){


			int c=(int)words[i];

			//首字符,从第一层Node中搜索
			if(0==i){
				temp=getFirstLvNode().get(c);

				//第一层node内不存在此字符,增加
				if(null==temp){
					temp=addNewTrieNode(getFirstLvNode(),words, i);
				}
				tempFather=temp;

			//其他字符
			}else{
				temp=tempFather.get(c);

				//node内不存在此字符,增加
				if(null==temp){
					temp=addNewTrieNode(tempFather,words, i);
				}

				tempFather=temp;

			}
		}

		tempFather.setObj(obj);

		getEntityNodes().add(tempFather);
		entityTrieNodeSize++;

		return tempFather;
	}

	public TrieNode insert(String word){
		return insert(word,null);
	}


	public TrieNode addNewTrieNode(TrieNode tempFather,char[] words,int i){
		TrieNode trieNode = new TrieNode((int)words[i],new String(words,0,i+1));
		trieNodeSize++;
		tempFather.add(trieNode);
		return trieNode;
	}

	/**
	 * 搜索输入的词 返回节点 并在搜索次数中+1
	 */
	public TrieNode search(String word){

		TrieNode node= get(word);

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

		return node.addClick();
	};


	public TrieNode get(String word){

		char[] words=word.toCharArray();

		TrieNode temp=null;

		for(int i=0;i<words.length;i++){
			int c=(int)words[i];

			//首字符
			if(0==i){
				temp=getFirstLvNode().get(c);
				if(temp==null){
					return null;
				}
			//其他层的字符
			}else{
				if(temp==null){
					return null;
				}
				temp=temp.get(c);
			}

		}

		return temp;
	};

	/**
	 * 根据设定的禁用词来过滤节点
	 */
	public boolean filter(String word){

		if(null==filterWords){
			return false;
		}

		boolean result = filterWords.add(word);
		if(result){
			filterWords.remove(word);
		}
		return !result;
	}


	/**
	 * 搜索输入的词与该词所有前缀
	 */
	public List<TrieNode> searchAndPrefix(String word){

		List<TrieNode> nodes=new ArrayList<TrieNode>();

		char[] words=word.toCharArray();

		TrieNode temp=null;

		for(int i=0;i<words.length;i++){
			int c=(int)words[i];

			//首字符
			if(0==i){
				temp=getFirstLvNode().get(c);
				if(temp==null){
					return null;
				}
			//其他层的字符
			}else{
				if(temp==null){
					return null;
				}
				temp=temp.get(c);
			}

			nodes.add(temp);
		}

		temp.addClick();

		return nodes;

	};

	public List<TrieNode> searchAndPrefix(String word,int lv){

		List<TrieNode> nodes=new ArrayList<TrieNode>();

		char[] words=word.toCharArray();

		TrieNode temp=null;

		for(int i=0;i<words.length;i++){
			int c=(int)words[i];

			if(0==i){
				temp=getFirstLvNode().get(c);
				if(temp==null){
					return null;
				}
			}else{
				if(temp==null){
					return null;
				}
				temp=temp.get(c);
			}

			if(i>lv-1){
				nodes.add(temp);
			}

		}

		temp.addClick();

		return nodes;

	};	

	/**
	 * 搜索前缀找出相关的词,按顺序取词
	 */
	public List<TrieNode> searchByPrefix(String word){

		return searchByPrefix(word,true,0);
	};

	/**
	 * 搜索前缀找出相关的词,并根据排序取词
	 */
	public List<TrieNode> searchByPrefix(String word,boolean desc,int size){
		List<TrieNode> list=new ArrayList<TrieNode>();
		TrieNode node=get(word);
		if(null==node){
			return list;
		}
		list.add(node);
		list.addAll(node.getAllChild());
		return sort(list,desc,size);
	};

	public List<TrieNode> sort(boolean desc,int size){
		return sort(getEntityNodes(),desc,size);
	}

	/**
	 * 对所有实体根据click进行排序，取出规定数量的节点
	 * desc true为默认逆序，false默认顺序
	 */
	public List<TrieNode> sort(List<TrieNode> elist,boolean desc,int size){
		java.util.Collections.sort(elist);
		if(size<=0||size>elist.size()){
			size=elist.size();
		}
		if(desc){
			return elist.subList(0,size);
		}else{
			List<TrieNode> list =elist.subList(elist.size()-size,elist.size());
			java.util.Collections.reverse(list);
			return list;
		}
	}

	public TrieNode getFirstLvNode() {
		if(null==firstLvNode){
			setFirstLvNode(new TrieNode());
		}
		return firstLvNode;
	}

	public void setFirstLvNode(TrieNode firstLvNode) {
		this.firstLvNode = firstLvNode;
	}

	public Set<String> getFilterWords() {
		if(null==filterWords){
			filterWords=new HashSet<String>();
		}
		return filterWords;
	}

	public void setFilterWords(Set<String> filterWords) {
		this.filterWords = filterWords;
	}

	public int getTrieNodeSize() {
		return trieNodeSize;
	}

	public void setTrieNodeSize(int trieNodeSize) {
		this.trieNodeSize = trieNodeSize;
	}

	public void addFilterWord(String word){
		getFilterWords().add(word);
	}

	public int getEntityTrieNodeSize() {
		return entityTrieNodeSize;
	}

	public void setEntityTrieNodeSize(int entityTrieNodeSize) {
		this.entityTrieNodeSize = entityTrieNodeSize;
	}

	public List<TrieNode> getEntityNodes() {
		if(null==entityNodes){
			entityNodes=java.util.Collections.synchronizedList(new ArrayList());
		}

		return entityNodes;
	}

	public void setEntityNodes(List entityNodes) {
		this.entityNodes = entityNodes;
	}


}