java数据结构----二叉树

1.   实现二叉树的各种遍历

package com.jzm.stackQueueTree;

public class BinTree {
  private final static int MAX = 50;
  private Object  data;
  private BinTree left,right;
  
  BinTree[] elements = new BinTree[MAX];
  int front ;
  int rear;
  
   
  public BinTree() {
	  
  }	
  
  public BinTree(Object data) {
	   this.data = data;
	   left = right = null;
  }	
 
  
  public BinTree(Object data,BinTree left,BinTree right){
	  this.data = data;
	  this.left = left;
	  this.right = right;	    
  }
  
    @Override
	public String toString() {
         return data.toString();
	}
    
    
        
    //前序遍历
    
    public static void preOrder(BinTree parent){
    	 if (parent == null) {
			 return;
		 }  	
    	 
    	System.out.print(parent.data+" ");
    	preOrder(parent.left);
    	preOrder(parent.right);   	
    }
  
    
    //中序遍历
    public static void inOrder(BinTree parent){
    	 if (parent == null) {
			 return;
		 }  	
    	 
    	inOrder(parent.left);
    	System.out.print(parent.data+" ");
    	inOrder(parent.right);   	
    }
  
    
    //后序遍历
    public static void postOrder(BinTree parent){
    	 if (parent == null) {
			 return;
		 }  		     	
    	postOrder(parent.left);
    	postOrder(parent.right);   	
    	System.out.print(parent.data+" ");
    }
  
    //层次遍历
    
    public void LayerOrder(BinTree parent){   	
    	elements[0] = parent;
    	front = 0;
    	rear = 1;
    	while(front < rear){
    		try{    		
    			if (elements[front].data != null) {
    				System.out.print(elements[front].data+" ");					
				     if(elements[front].left !=null)			    	 
				    	 elements[rear++] = elements[front].left;			     
                     if(elements[front].right !=null)    	 
				    	 elements[rear++] = elements[front].right;
				    	 
				         front++;   			
    			   }//end if	  			
    		}catch(Exception e){
				break;
    		}   		   		
    	} //end while  	
    }
      
    //求树的高度
    public  int  height(){
    	  int height = 0;
    	  if(this ==null){
    		  return -1;
    	  }   	  
    	  int  leftHeigt = ( (left == null)? 0:left.height() );
    	  int  rightHeigt=( (right ==null)?0:right.height() );
    	  height = leftHeigt < rightHeigt ?rightHeigt:leftHeigt;
          return height+1;
    }
 
    //如果对象不在树中，结果返回-1，否则返回对象在树中的层次，规定根节点为第一层   
    public   int  level(Object object){
      
      int  levelTree =0;    
  	  if(this == null){
  		  return -1;
  	  }  
  	  //规定根节点为第一层
  	  if(object.equals(data)){  		   
  		   return  1;  	 
  	  }
  
  	  int  leftLevel  = (  (left == null)?  -1:left.level(object) );
  	  int  rightLevel = (  (right ==null)?  -1:right.level(object) );
  	 
  	  if (leftLevel < 0 &&  rightLevel < 0) {
		      return -1;
	  }
 	  
  	  levelTree = (leftLevel < rightLevel)? rightLevel:leftLevel;      
  	     return   levelTree+1;
  }
   
    //将树中每一个节点的孩子对换位置 
    public void reflect(){
    	 
    	if(this == null)
    		return ;
    	if (left != null) {
			left.reflect();
		}
    	if(right != null){
    		right.reflect();
    	}
    	BinTree temp = left;
    	left = right;
    	right = temp;   	  	
    }
    
    //将树中所有的节点移走，并输出移走的节点
    
    public  void   defoliate(){
    	String innerNode = "";
    	if(this == null)
    		return;
    	//如为叶节点，移走
    	if(left == null && right ==null){
    		 System.out.print(this + "");
    		 data = null;
    		 return ;   		
    	}
    	
    	//移走左子树
    	if(left != null){
    		left.defoliate();
    		left = null;
    	}
    	
    	innerNode += this +" ";
    	data = null;
    	
    	//移走右子树
    	if(right != null){
    		right.defoliate();
    		right = null;
    	}   	  	
    }
    
    public static void main(String[] args) {
    	 BinTree e = new BinTree("E");
    	 BinTree g = new BinTree("G");   	    
    	 BinTree h = new BinTree("H");   	    
    	 BinTree i = new BinTree("I");
    	    
    	 BinTree d = new BinTree("D",null,g);    	 
    	 BinTree f = new BinTree("F",h,i);  	 
    	 BinTree b = new BinTree("B",d,e);
    	 BinTree c = new BinTree("C",f,null);   	    
    	 BinTree tree = new BinTree("A", b, c);   
 	     
    	 System.out.println("heigh="+tree.height());
    	
    	 
    	 System.out.println("前序结果：");
    	 tree.preOrder(tree);   	 
    	 System.out.println("");
    	 

    	 System.out.println("中序结果：");
    	 tree.inOrder(tree);   	 
    	 System.out.println("");
    	   	 

    	 System.out.println("后序结果：");
    	 tree.postOrder(tree);   	 
    	 System.out.println("");
    	 

    	 System.out.println("层次遍历结果：");
    	 tree.LayerOrder(tree);   	 
    	 System.out.println("");
    	 
    	 System.out.println("level(d)"+tree.level("B"));  	 
	}
      
}