Java实现完全二叉树的构建以及三种遍历方式

1. 简介：
   将一个数组{1,2,3,4,5,6,7,8,9}依次转化为Node节点，本例中节点由int型数据和指向左右子节点对象的引用构成，然后将所有节点构造成一个完全二叉树。
2. 实现过程：

package binaryTree;

import java.util.LinkedList;
import java.util.List;

/**
 * 功能: 把一个数组的值存入二叉树中，然后进行三种方式的遍历
 * @author fei
 * 知识点：二叉树的定义和遍历
 */

public class BinaryTree {
    private int[] array={1,2,3,4,5,6,7,8,9};
    private static List<Node> nodeList = null;
    /**
     * 内部类：节点
     * 节点内容：数据，指向左孩子和右孩子的引用。
     * */
    private static class Node{
        Node leftNode;
        Node rightNode;
        int data;
        Node(int newData){
            leftNode = null;
            rightNode=null;
            data=newData;
        }
    }

    /**
     * 创建一颗二叉树
     */
    public void createBinTree(){
        //容器，里边存的是所有的结点
        nodeList = new LinkedList<Node>();
        for(int nodeIndex = 0; nodeIndex<array.length;nodeIndex++){
            nodeList.add(new Node(array[nodeIndex]));
        }
        // 对前lastParentIndex-1个父节点按照父节点与孩子节点的数字关系建立二叉树  
        for(int parentIndex =0;parentIndex<array.length/2-1;parentIndex++){
            //左孩子
            nodeList.get(parentIndex).leftNode = nodeList.get(parentIndex*2 +1);
            //右孩子
            nodeList.get(parentIndex).rightNode=nodeList.get(parentIndex*2+2);
        }
        //最后一个父节点，因为可能没有右孩子，所以要单独拿出来处理
        int lastParentIndex = array.length /2 -1;
        //左孩子
        nodeList.get(lastParentIndex).leftNode = nodeList.get(lastParentIndex*2+1);
        //如果存在右孩子才建立右孩子
        if(array.length % 2 == 1){
            nodeList.get(lastParentIndex).rightNode= nodeList.get(lastParentIndex*2+2);
        }
    }
    /**
     * 先序遍历
     */
    public static void preOrderTraverse(Node node){
        if(node==null){
            return;
        }
        System.out.print(node.data + " ");
        preOrderTraverse(node.leftNode);
        preOrderTraverse(node.rightNode);
    }
    /**
     * 中序遍历
     */
    public static void inOrderTraverse(Node node){
        if(node==null){
            return;
        }   
        preOrderTraverse(node.leftNode);
        System.out.print(node.data + " ");
        preOrderTraverse(node.rightNode);
    }
    /**
     * 后序遍历
     */
    public static void postOrderTraverse(Node node){
        if(node==null){
            return;
        }   
        preOrderTraverse(node.leftNode);
        preOrderTraverse(node.rightNode);
        System.out.print(node.data + " ");
    }
     public static void main(String[] args) {  
            BinaryTree binTree = new BinaryTree();  
            binTree.createBinTree();  
            // nodeList中第0个索引处的值即为根节点  
            Node root = nodeList.get(0);  
            System.out.println("root = "+root.data);
            System.out.println("先序遍历：");  
            preOrderTraverse(root);  
            System.out.println();  

            System.out.println("中序遍历：");  
            inOrderTraverse(root);  
            System.out.println();  

            System.out.println("后序遍历：");  
            postOrderTraverse(root);  
        }  
}
**输出结果：**
root = 1
先序遍历：
1 2 4 8 9 5 3 6 7 
中序遍历：
2 4 8 9 5 1 3 6 7 
后序遍历：
2 4 8 9 5 3 6 7 1