java中二叉树的创建以及几个常用的函数

二叉树是我们在编程过程中常用的数据模型，但是java本身并没有提供简单的二叉树类以供调用，今天我们就自己写了一个BinaryTreeFactory类，用来创建一棵二叉树，并且提供先序遍历，中序遍历，后序遍历，层次遍历这几种不同的遍历方式。

废话不多说，上代码

首先是二叉树的节点类，你可以将它写成内部类的形式

/**
 * 
 * @author yyd
 *二叉树的节点类
 */
public class BTNode {
	private BTNode left;  
    private BTNode right;  
    private int data;  
    public BTNode(int data){  
        this.left = null;  
        this.right = null;  
        this.data = data;  
    }
	public BTNode getLeft() {
		return left;
	}
	public void setLeft(BTNode left) {
		this.left = left;
	}
	public BTNode getRight() {
		return right;
	}
	public void setRight(BTNode right) {
		this.right = right;
	}
	public int getData() {
		return data;
	}
	public void setData(int data) {
		this.data = data;
	} 

}

接下来是BinaryTreeFactory类，即是一个工厂类，提供多种创建方法以及遍历方法

/**
 * 
 * @author pc
 *工厂类
 *用来产生二叉树，返回的是所生成二叉树的根节点
 *并且提供先序，中序，后序，层次遍历四种遍历方式
 *提供查找某节点以及该节点高度的方法
 */
public class BinaryTreeFactory {
	
	/**
     * 根据一个数组来创建二叉树
     * @param a[0..n] n+1个数据组成的数组，其中a[0]=-1不参与树的创建
     * a[1]~a[n]代表数的节点，a[2*i]是a[i]的左子结点，a[2*i+1]是右子节点
     * 若a[t]=-1则代表该节点为空节点
     */
    public static BTNode buildTreeByArray(int[] a,int n){
    	BTNode[] p=new BTNode[n+1];
    	p[0]=null;
    	for(int i=1;i<=n;i++){
    		if(a[i]==-1){
    			p[i]=null;
    		}
    		else{
    			p[i]=new BTNode(a[i]);
    		}
    	}
    	for(int i=1;i<=n/2;i++){
    		if(a[i]!=-1){
    			if((2*i<=n)&&a[2*i]!=-1){
    				p[i].setLeft(p[2*i]);
    			}
    			if((2*i+1<=n)&&(a[2*i+1]!=-1)){
    				p[i].setRight(p[2*i+1]);
    			}
    		}
    	}
    	return p[1];
    }
    
    /**
     * 根据一个先序遍历数组和一个中序遍历数组建立一棵二叉树
     * 数组从1开始，pre[0]=-1与in[0]=-1不参与树的构建
     */
    public static BTNode buildByPreInOrder(int[] pre,int[] in,int prelow,int prehigh,int inlow,int inhigh){
    	if((prehigh-prelow>=0)&&(inhigh-inlow>=0)){
    		BTNode n=new BTNode(pre[prelow]);
    		int k=inlow;
    		for(int i=inlow;i<=inhigh;i++){
    			if(pre[prelow]==in[i]){
    				k=i;
    				break;
    			}
    		}
    		n.setLeft(buildByPreInOrder(pre,in,prelow+1,prelow+k-1,inlow,k-1));
    		n.setRight(buildByPreInOrder(pre, in, prelow+k, prehigh, k+1, inhigh));
    		return n;
    	}
    	else
    		return null;
    }
    
    
    /**
     * 根据一个中序遍历数组和一个后序遍历数组建立一棵二叉树
     * 数组从1开始，post[0]=-1与in[0]=-1不参与树的构建
     */
    public static BTNode buildByInPostOrder(int[] in,int[] post,int inlow,int inhigh,int postlow,int posthigh){
    	if((posthigh-postlow>=0)&&(inhigh-inlow>=0)){
    		BTNode n=new BTNode(post[posthigh]);
    		int k=inlow;
    		for(int i=inlow;i<=inhigh;i++){
    			if(post[posthigh]==in[i]){
    				k=i;
    				break;
    			}
    		}
    		int leftLen=k-inlow;
    		int rightLen=inhigh-k;
    		n.setLeft(buildByInPostOrder(in,post,inlow,inlow+leftLen-1,postlow,postlow+leftLen-1));
    		n.setRight(buildByInPostOrder(in,post, k+1, inhigh, postlow+leftLen, posthigh-1));
    		return n;
    	}
    	else
    		return null;
    }
    
    /** 
     * 前序遍历 
     * @param node 
     */  
    public static void preOrder(BTNode node){  
        if(node != null){  
            System.out.print(node.getData()+" ");  
            preOrder(node.getLeft());  
            preOrder(node.getRight());  
        }  
    }  
      
    /** 
     * 中序遍历 
     * @param node 
     */  
    public static void inOrder(BTNode node){  
        if(node != null){  
            inOrder(node.getLeft());  
            System.out.print(node.getData()+" ");  
            inOrder(node.getRight());  
        }  
    }  
      
    /** 
     * 后序遍历 
     * @param node 
     */  
    public static void postOrder(BTNode node){  
        if(node != null){  
            postOrder(node.getLeft());  
            postOrder(node.getRight());  
            System.out.print(node.getData()+" ");  
        }  
    }  
    
    /**
     * 层次遍历
     * @param node
     */
    public static void levelOrder(BTNode node){
    	BTNode[] queue=new BTNode[255];
    	int tail=0;
    	int head=0;//队头指针与队尾指针
    	BTNode p=node;
    	if(p!=null){
    		queue[tail++]=node;//将节点加入队列中
    		while(head!=tail){//即队不空
    			BTNode temp=queue[head++];
    			System.out.print(temp.getData()+" ");
    			if(temp.getLeft()!=null){
    				queue[tail++]=temp.getLeft();
    			}
    			if(temp.getRight()!=null){
    				queue[tail++]=temp.getRight();
    			}
    		}
    	}
    }
    
    /**
     * 从以node为根的树中找出值为x的节点，若找到就返回该节点，否则返回null
     * @param x
     * @param node
     */
    public static BTNode find(int x,BTNode node){
    	if(node!=null){
    		if(node.getData()==x){
    			return node;
    		}
    		else{
    			BTNode t=find(x,node.getLeft());
    			if(t!=null)
    				return t;
    			else
    				return find(x,node.getRight());
    		}
    	}
    	else{
    		return null;
    	}
    }
    
    /**
     * 给出一个节点判断它在树中的高度
     * @param node
     * @return
     */
    public static int getDepth(BTNode node){
    	if(node==null)
    		return 0;
    	else{
    		int lh=getDepth(node.getLeft());
    		int rh=getDepth(node.getRight());
    		return lh>=rh?lh+1:rh+1;
    	}
    }
    
    

}