java实现二叉树的构建以及3种遍历方法

目录： 

1.把一个数组的值赋值给一颗二叉树 

2.具体代码 

1.树的构建方法 

package cn.com.niuke.shujujiegou;

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

public class BinaryTreeTraverse {
	
	private int[]  arr = {1,2,3,4,5,6,7,8,9};
	private static List<Node> nodeList =  new ArrayList<Node>();
	
	/*
	 * 内部类：节点
	 */
	private static class Node{
		Node leftChild;
		Node rightChild;
		int data;
		
		Node(int newData){
			leftChild = null;
			rightChild = null;
			data = newData;
		}
	}
	
	/*
	 * 创建二叉树
	 */
    public void creatBinaryTree(){
    	//将数组的值依次转为Node节点list
    	for(Integer i:arr){
    		nodeList.add(new Node(i));
    	}
    	// 对前lastParentIndex-1个父节点按照父节点与孩子节点的数字关系建立二叉树 
    	for(int parentIndex = 0;parentIndex<arr.length/2-1;parentIndex++){
    		//左孩子
    		nodeList.get(parentIndex).leftChild = nodeList.get(parentIndex*2+1);
    		//右孩子
    		nodeList.get(parentIndex).rightChild = nodeList.get(parentIndex*2+2);
    	}
    	//最后一个父节点：因为最后一个父节点可能没有右孩子，所以单独处理
    	int lastParentIndex = arr.length/2-1;
    	//左孩子
    	nodeList.get(lastParentIndex).leftChild = nodeList.get(lastParentIndex*2+1);
    	//右孩子，如果数组的长度是奇数，才有右孩子
    	if(arr.length%2==1){
    		nodeList.get(lastParentIndex).rightChild = nodeList.get(lastParentIndex*2+2);    	
    		}
     }
    
    /** 
     * 先序遍历 （根左右）
     *  
     * 这三种不同的遍历结构都是一样的，只是先后顺序不一样而已 
     *  
     * @param node 
     *            遍历的节点 
     * @return 
     */  
    public static void preOrderTraverse(Node node){
    	if(node==null)
    		return;
    	System.out.print(node.data+" ");
    	preOrderTraverse(node.leftChild);
    	preOrderTraverse(node.rightChild);
    }
    
    /** 
     * 先序遍历 （根左右）
     *  
     * 这三种不同的遍历结构都是一样的，只是先后顺序不一样而已 
     *  
     * @param node 
     *            遍历的节点 
     * @return 
     */  
    public static void inOrderTraverse(Node node){
    	if(node==null)
    		return;  	
    	inOrderTraverse(node.leftChild);
    	System.out.print(node.data+" ");
    	inOrderTraverse(node.rightChild);
    }
    
    /** 
     * 先序遍历 （根左右）
     *  
     * 这三种不同的遍历结构都是一样的，只是先后顺序不一样而已 
     *  
     * @param node 
     *            遍历的节点 
     * @return 
     */  
    public static void postOrderTraverse(Node node){
    	if(node==null)
    		return;
    	postOrderTraverse(node.leftChild);
    	postOrderTraverse(node.rightChild);
    	System.out.print(node.data+" ");
    }
    
    public static void main(String[] args) {
    	BinaryTreeTraverse binTree = new BinaryTreeTraverse();
    	binTree.creatBinaryTree();
    	//nodeList中的第0个索引处的值即为根节点
    	Node root = nodeList.get(0);
    	
        System.out.println("先序遍历：");
        preOrderTraverse(root);
        System.out.println();
        
        System.out.println("中序遍历：");
        inOrderTraverse(root);
        System.out.println();
        
        System.out.println("后序遍历：");
        postOrderTraverse(root);
	}
	

}