2013.12.18

* 用数组表示树，结点的左子结点为2*index+1，右子结点为2*index+2，父结点为（index-1）/2；

* 树的任何操作都需要考虑到根结点；

写了一段让自己好有成就感的代码，哈哈

二叉搜索树，包含delete（），insert（），find（），以及前中后遍历，并且具有以树型结构输出显示的display（）方法@java/DataStructrue/unit8

import java.util.*;

class Node{
	public Data d;
	public Node left;
	public Node right;

	public Node(Data d){
		this.d=d;
		left=null;
		right=null;
	}

	public void display(){
		System.out.print("["+d.iData+", "+d.dData+"] ");
	}
}

class Data{
	public int iData;
	public double dData;

	public Data(int iData, double dData){
		this.iData=iData;
		this.dData=dData;
	}
}

class Tree{
	private Node root;
	private int displayCounter=0;

	public Tree(){
		root=null;
	}

	public void display(){
		NodeStack cStack=new NodeStack(100);
		NodeStack dStack=new NodeStack(100);
		Node temp;
		int size=1;
		cStack.push(root);
		boolean flag=true;

		while(true){
			flag=false;
			while(!cStack.isEmpty()){
				dStack.push(cStack.pop());
			}
			Node [] nArr=new Node[size];
			int ptr=0;
			while(!dStack.isEmpty()){
				temp=dStack.pop();
				nArr[ptr++]=temp;
				if(temp==null){
					cStack.push(null);
					cStack.push(null);
				}
				else{
					cStack.push(temp.left);
					cStack.push(temp.right);
					flag=true;
				}
			}
			if(!flag) break;
	//		System.out.println("cStack "+cStack.depth());
			if(flag) output(nArr);
			size*=2;
		}
	}

	 private void output(Node [] nArr){
		char [] cArr=new char[32];
		int ptr=0;
		for(int i=0; i<cArr.length; i++) cArr[i]=' ';
		int step=cArr.length/(nArr.length+1);
		for(int i=0; i<nArr.length; i++){
			if(nArr[i]==null) cArr[step*(i+1)-1]='~';
			else cArr[step*(i+1)-1]=(char)(nArr[i].d.iData+48);
		}
		for(int i=0; i<cArr.length; i++) System.out.print(cArr[i]);
		System.out.println();
	}

	public Node find(int key){
		Node current=root;
		while(key!=current.d.iData){
			if(key<current.d.iData) current=current.left;
			else current=current.right;
		}
		return current;
	}

	public void insert(int iData, double dData){
		Node n=new Node(new Data(iData, dData));
		Node current=root;
		Node prev=root;
		if(root==null){root=n; prev=root; current=root;}
		else{
			while(current!=null){
				if(iData<=current.d.iData){
					prev=current;
					current=current.left;
				}
				else{
					prev=current;
					current=current.right;
				}
			}
			if(prev.d.iData>=iData) prev.left=n;
			else prev.right=n;
		}
	}

	public Node delete(int iData){
		Node current, prev;
		current=root;
		prev=root;
		while(iData!=current.d.iData && current!=null){
			prev=current;
			if(iData<current.d.iData) current=current.left;
			else current=current.right;
		}
		if(current==null) return null;
		if(current.left==null && current.right==null){
			if(prev.d.iData>=iData) prev.left=null;
			else prev.right=null;
		}
		else if(current.left!=null && current.right!=null){
			Node next=current.left;
			Node prev1=next;
			if(next.right==null){
				if(current==root){
					next.right=current.right;
					root=next;
				}
				else{
					if(prev.left==current) prev.left=next;
					else prev.right=next;
					next.right=current.right;
				}
			}
			else{
				while(next.right!=null){
					prev1=next;
					next=next.right;
				}
				prev1.right=next.left;
				if(current==root) root=next;
				else{
					if(prev.left==current) prev.left=next;
					else prev.right=next;
				}
					next.right=current.right;
					next.left=current.left;
			}
		}
		else{
			if(current.left!=null){
				if(prev.left==current) prev.left=current.left;
				else prev.right=current.left;
			}
			else{
				if(prev.left==current) prev.left=current.right;
				else prev.right=current.right;
			}
		}
		return current;
	}

//中序遍历为从小到大输出二叉搜索树元素
	public void inOrderTransverse(){
		displayCounter=0;
		inOrder(root);
	}

	private void inOrder(Node n){
		if(n==null) return;
		else{
			inOrder(n.left);
			n.display();
			if(++displayCounter%3==0) System.out.println();
			inOrder(n.right);
		}
	}
//前序遍历
	public void preOrderTransverse(){
		displayCounter=0;
		preOrder(root);
	}

	public void preOrder(Node n){
		if(n==null) return;
		else{
			n.display();
			if(++displayCounter%3==0) System.out.println();
			preOrder(n.left);
			preOrder(n.right);
		}
	}
//后序遍历
	public void postOrderTransverse(){
		displayCounter=0;
		postOrder(root);
	}

	public void postOrder(Node n){
		if(n==null) return;
		else{
			postOrder(n.left);
			postOrder(n.right);
			n.display();
			if(++displayCounter%3==0) System.out.println();
		}
	}
}

public class TestBinaryTree{
	public static void main(String [] args){
		Tree tree=new Tree();
		tree.insert(5, 1.0);
		tree.insert(3, 1.0);
		tree.insert(9, 1.0);
		tree.insert(4, 1.0);
//		tree.insert(1, 1.0);
//		tree.insert(2, 1.0);
//		tree.insert(6, 1.0);
		tree.insert(7, 1.0);
		tree.insert(8, 1.0);
//		tree.insert(10, 1.0);
//		tree.insert(0, 1.0);
		tree.display();
	}
}