一般二叉树的创建，前序，中序，后序遍历

二叉树的前序，中序，后序遍历顺序，可以理解成是以根节点的访问顺序来定义的，

比如：

前序遍历：根节点，左子树节点，右子树节点，

中序遍历：左子树节点，根节点，右子树节点，

后序遍历：左子树节点，右子树节点，根节点，

先创建一个Node类来存储节点的值，左子树和右子树

package tree;

public class Node {
    //也可以将其节点定义为内部类
            public Node right; //右子树节点
            public Node left;    //左子树节点
            public int date;    //该节点存放的值
            Node(int newdate){
                right=null;
                left=null;
                date=newdate;
            }

}

一般二叉树的实现类

package tree;

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

public class Tree {
    //给一个默认的数组来构建二叉树
    private int[] array= {1,2,3,4,5,6,7,8,9};
    //声明一个Node类型的list集合来存储二叉树的结构
    private static List<Node> nodelist=null;
//    //将节点定义为内部类，因为在其它类中也需要使用到这个Node类，为了方便就不定义成内部类了
//        private static class Node{
//            Node right;
//            Node left;
//            int date;
//            Node(int newdate){
//                right=null;
//                left=null;
//                date=newdate;
//            }
//        }
    public void createTree() {
        //创建一个双链表作为队列
        nodelist=new LinkedList<Node>();
        //将数组的值全部转换为Node节点
        for(int nodelistIndex=0;nodelistIndex<array.length;nodelistIndex++ ) {
            nodelist.add(new Node(array[nodelistIndex]));
        }
        /***
         *           1
         *         /   
         *        2     3
         *       /     /
         *      4  5   6  7
         */
        for(int parentIndex=0;parentIndex<(array.length/2-1);parentIndex++) {
            //左孩子节点
            nodelist.get(parentIndex).left=nodelist.get(parentIndex*2+1);
            //右孩子节点
            nodelist.get(parentIndex).right=nodelist.get(parentIndex*2+2);
        }
        /***
         *           1
         *         /   
         *        2     3
         *       /     /
         *      4  5   6  7
         *     / 
         *    8   9
         */
        //最后一个父节点可能只有左孩子节点没有右孩子节点
        int lastParentIndex=array.length/2-1;
        nodelist.get(lastParentIndex).left=nodelist.get(lastParentIndex*2+1);
        //如果array的数组长度为奇数，则最后一个父节点有右孩子节点
        if(array.length%2==1) {
            nodelist.get(lastParentIndex).right=nodelist.get(lastParentIndex*2+2);
        }
    }
    /**
     *     使用递归的方式来遍历二叉树
     * @param node
     */
    //先序遍历---》根节点，左节点，右节点
    public static void preOrdertraverse(Node node){
        if(node==null) return;
        System.out.print(node.date+"-");
        preOrdertraverse(node.left);
        preOrdertraverse(node.right);
    }
    //中序遍历---》左节点，根节点，右节点
    public static void inOrdertraverse(Node node) {
        if(node==null)return;
        inOrdertraverse(node.left);
        System.out.print(node.date+"-");
        inOrdertraverse(node.right);
    }
    //后序遍历---》左节点，右节点，根节点
    public static void postOrdertraverse(Node node) {
        if(node==null) return;
        postOrdertraverse(node.left);
        postOrdertraverse(node.right);
        System.out.print(node.date+"-");
    }
    /**
     *     得到二叉树的根节点，用作遍历的始节点
     *     
     * @return
     */
    public Node getNodelist() {
        return nodelist.get(0);
    }
    /**
     *     设置二叉树的结构和值，构建时是传入的数组会以下标从小到大按根，左，右顺序构建，例如：
     *         {1,2,3,4,5,6,7,8,9}
     *             会被构建成
     *           1
     *         /   
     *        2     3
     *       /     /
     *      4  5   6  7
     *     / 
     *    8   9
     * @param array
     */
    public void setArray(int[] array) {
        this.array = array;
    }
}

前中后序遍历测试代码：

@org.junit.Test
    public void BinTreeTest() {
        Tree tree=new Tree();
        tree.createTree();
        System.out.println("前序遍历");
        Tree.preOrdertraverse(tree.getNodelist());
        System.out.println();
        System.out.println("中序遍历");
        Tree.inOrdertraverse(tree.getNodelist());
        System.out.println();
        System.out.println("后序遍历");
        Tree.postOrdertraverse(tree.getNodelist());
    }

测试结果：