二叉树的算法

import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.BlockingDeque;
import tree.BiTreeTraverse.Node;

/**
 * 二叉树的三种遍历：
 * 先序遍历、中序遍历、后续遍历
 * @author Administrator
 *                    1
 *                  /   
 *                2      3
 *               /      / 
 *             4   5   6   7
 *            / 
 *          8    9 
 * 二叉树是每个节点最多只有两个子节点的有序树
 * 先序遍历：根->左子树->右子树        1,2,4,8,9,5,3,6,7    
 * 中序遍历：左子树->根->右子树        8,4,9,2,5,1,6,3,7
 * 后续遍历：左子树->右子树->根         8,9,4,5,2,6,7,3,1
 * 
 *               
 */
public class BiTreeTraverse {
    private int[] array = {1,2,3,4,5,6,7,8,9};
    private static List<Node> nodeList = null;
    public static class Node{
        Node leftChild;
        Node rightChild;
        int data;
        public Node(int newData) {
            data = newData;
            leftChild = null;
            rightChild = null;
        }
    }
    public void createBitree() {
        nodeList = new LinkedList<Node>();
        for (int nodeIndex = 0; nodeIndex < array.length; nodeIndex++) {
            nodeList.add(new Node(array[nodeIndex]));
        }
        for (int parentIndex = 0; parentIndex < array.length/2-1; parentIndex++) {
            nodeList.get(parentIndex).leftChild = nodeList.get(parentIndex*2+1);
            nodeList.get(parentIndex).rightChild = nodeList.get(parentIndex*2+2);
        }
        int lastParentIndex = array.length/2-1;
        nodeList.get(lastParentIndex).leftChild = nodeList.get(lastParentIndex*2+1);
        if (array.length%2==1) {
            nodeList.get(lastParentIndex).rightChild = nodeList.get(lastParentIndex*2+2);
        }    
    }
    /**
     * 先序遍历
     * @param node
     */
    public static void preOrderTraverse(Node node) {
        if (node ==null) {
            return ;
        }
        System.out.print(node.data+",");
        preOrderTraverse(node.leftChild);
        preOrderTraverse(node.rightChild);
    }
    public static void inOrderTraverse(Node node) {
        if (node ==null) {
            return ;
        }
        
        inOrderTraverse(node.leftChild);
        System.out.print(node.data+",");
        inOrderTraverse(node.rightChild);
    }
    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) {
        BiTreeTraverse biTree = new BiTreeTraverse();
        biTree.createBitree();
        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);
    }
    
 }