//树节点的实现

package tree;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.Stack;

public class BinTreeNode {
	private Object data;
	private int height;
	private int size;
	private BinTreeNode lChild;
	private BinTreeNode rChild;
	public BinTreeNode(){
		this(null);
	}
	public BinTreeNode(Object data){
		this.data = data;
	}
	private BinTreeNode parent;
	public Object getData() {
		return data;
	}
	public void setData(Object data) {
		this.data = data;
	}
	public int getHeight() {
		return height;
	}
	public void setHeight(int height) {
		this.height = height;
	}
	public int getSize() {
		return size;
	}
	public void setSize(int size) {
		this.size = size;
	}
	public BinTreeNode getlChild() {
		return lChild;
	}
	public BinTreeNode setlChild(BinTreeNode lChild) {
		BinTreeNode oldLeftChild = getlChild();
		if(hasLChild()) oldLeftChild.sever();
		if(lChild!=null){
			lChild.sever();
			this.setlChild(lChild);
			lChild.setParent(this);
			this.upDateHeight();
			this.upDateSize();
		}
		return oldLeftChild;
	}
	public BinTreeNode getrChild() {
		return rChild;
	}
	public BinTreeNode setrChild(BinTreeNode rChild) {
		BinTreeNode oldRightChild = getrChild();
		if(hasRightChild())oldRightChild.sever();
		if(rChild!=null){
			rChild.sever();
			rChild.setParent(this);
			this.setrChild(rChild);
		}
		return oldRightChild;
	}
	public BinTreeNode getParent() {
		return parent;
	}
	public void setParent(BinTreeNode parent) {
		this.parent = parent;
	}
	public boolean hasParent(){
		return parent!=null;
	}
	public boolean hasLChild(){
		return lChild!=null;
	}
	public boolean hasRightChild(){
		return rChild!=null;
	}
	public boolean isLeaf(){
		return getlChild()==null&&getrChild()==null;
	}
	public boolean isRightChild(){
		return hasParent()&& getParent().getrChild()==this;
	}
	public boolean isLeftChild(){
		return hasParent()&&getParent().getrChild()==this;
	}
	public void upDateHeight(){
		int newHeight =0;
		if(hasRightChild())newHeight=Math.max(newHeight, getrChild().getHeight()+1);
		if(hasLChild())newHeight = Math.max(newHeight, getlChild().getHeight()+1);
		if(newHeight==getHeight())return;
		setHeight(newHeight);
		//向上递归更新
		if(hasParent())getParent().upDateHeight();
	}
	public void upDateSize(){
		size = 1;
		if(hasLChild())size+=getlChild().getSize();
		if(hasRightChild())size+=getrChild().getSize();
		if(hasParent())getParent().upDateSize();
	}
	//断开与父节点的关系
	public void sever(){
		if(getParent()==null)return;
		if(isRightChild()){
			getParent().setrChild(null);}else{
				getParent().setlChild(null);
			}
		getParent().upDateHeight();
		getParent().upDateSize();
		setParent(null);
		
	}
	public Iterator PreOrder(){
		LinkedList list = new LinkedList<BinTreeNode>();
		PreOrderTravelRecusion(this,list);
		return list.iterator();
	}
	//前续递归算法
	private void PreOrderTravelRecusion(BinTreeNode root,LinkedList list){
		if(root==null) return;
	 list.add(root);
	 if(hasLChild())PreOrderTravelRecusion(getlChild(), list);
	 if(hasRightChild())PreOrderTravelRecusion(getrChild(), list);
	}
	//前续非递归算法
	private void PreOrderTravel(BinTreeNode root,LinkedList list){
		if(root==null) return;
		Stack stack =new Stack<BinTreeNode>();
		BinTreeNode p = root;
		while(p!=null){
			while(p!=null){
				list.add(p);
				if(p.hasRightChild())stack.push(p.getrChild());
				p=p.getlChild();
			}
			if(!stack.isEmpty())p=(BinTreeNode) stack.pop();
		}
	}
	//中序非递归算法
	private void inOrderTravel(BinTreeNode root,LinkedList list){
		BinTreeNode p =root;
		if(root==null)return;
		Stack stack = new Stack<BinTreeNode>();
		while(!stack.isEmpty()||p!=null){
			while(p!=null){
				stack.push(p);
				p = p.getlChild();
			}
			if(!stack.isEmpty()){
				p = (BinTreeNode) stack.pop();
				list.add(p);
				p=p.getrChild();
			}
		}
		
	}
	//后续遍历非递归
	private void postOrderTravel(BinTreeNode root,LinkedList list){
		if(root == null) return;
		BinTreeNode p = root;
		Stack stack = new Stack<BinTreeNode>();
		while(!stack.isEmpty()||p!=null){
			stack.push(p);
			if(p.hasLChild()){p=p.getlChild();
			}else{
				p = p.getrChild();
			}
		}
		if(!stack.isEmpty()){
			p = (BinTreeNode) stack.pop();
			list.add(p);
		}
		BinTreeNode top = (BinTreeNode) stack.peek();
		if(!stack.isEmpty()&&top.getrChild()==p){
			p = (BinTreeNode) stack.pop();
			list.add(p);
		}
		if(!stack.isEmpty())
		{
		p = top.getrChild();}else{
			p=null;
		}
	}
}

//Huffman节点

package tree;

public class HuffmanTreeNode extends BinTreeNode{
	private int weight;
	private String code="";
	public HuffmanTreeNode(int weight){
		this(weight,null);
	}
	public HuffmanTreeNode(int weight,Object data){
		super(data);
		this.weight=weight;
	}
	public int getWeight() {
		return weight;
	}
	public void setWeight(int weight) {
		this.weight = weight;
	}
	public String getCode() {
		return code;
	}
	public void setCode(String code) {
		this.code = code;
	}
	public HuffmanTreeNode getParent(){
		return (HuffmanTreeNode) super.getParent();
	}
	public HuffmanTreeNode getlChild(){
		return (HuffmanTreeNode) super.getlChild();
	}
	public HuffmanTreeNode getrChild(){
		return (HuffmanTreeNode) super.getrChild();
	}
}

//haffman的构造

package tree;

import java.util.ArrayList;
import java.util.List;

public class HuffmanTreeBuilder {
public static HuffmanTreeNode buildHuffmanTree(HuffmanTreeNode[] nodes){
int length = nodes.length;
List list = new ArrayList<HuffmanTreeNode>();
if(length<2){return nodes[0];}
for(int i=0;i<length;i++){
insertIntoList(nodes[i], list);
}
for(int i=0;i<length;i++){
HuffmanTreeNode min1 = (HuffmanTreeNode) list.remove(list.size()-1);
HuffmanTreeNode min2 = (HuffmanTreeNode) list.remove(list.size()-1);
HuffmanTreeNode newNode = new HuffmanTreeNode(min1.getWeight()+min2.getWeight());
newNode.setlChild(min1);
newNode.setrChild(min2);
min1.setParent(newNode);
min2.setParent(newNode);
insertIntoList(newNode, list);
}
return (HuffmanTreeNode) list.get(0);


}

//按照大小顺序插入链表中 ，具体的链表自己实现
public static void insertIntoList(HuffmanTreeNode node,List< HuffmanTreeNode> list){
for(int i=0;i<list.size();i++)
if(node.getWeight()>list.get(i).getWeight()){
list.add(node);
}
}
public static void generatorHuffmanTree(HuffmanTreeNode root){
if(root == null) return;
if(root.hasParent()){
if(root.isLeftChild()) root.setCode(root.getParent().getCode()+”0″);
if(root.isRightChild())root.setCode(root.getParent().getCode()+”1″);
}
generatorHuffmanTree(root.getlChild());
generatorHuffmanTree(root.getlChild());
}
}