java实现二叉树，以及二叉树的遍历和先序和后序求解

/**
 *  java实现一个二叉树 从外部传递一个数组来，来构建一个二叉树，
 *  或者由前后序以及中序遍历中来还原二叉树，前序和后序并不能唯一确定二叉树。
 */
public class BinaryTree {
//  二叉树的根节点
    private Node root;

    public BinaryTree(int[] array) {
        createBinTree(array);
    }

    private static class Node {
        Node leftChild;
        Node rightChild;
        int data;

        Node(int newData) {
            data = newData;
        }
    }

    // 根据后序遍历结果和中续遍历结果创建一个二叉树，并返回该二叉树的root节点
    public static Node createNewTreeByML(int[] inorder, int[] lastorder) throws Exception {
        // 如果二叉树的前序数组长度为0，是不用返回一个空节点的，直接返回null，说明该节点没有左孩子或者右孩子
        if (lastorder == null || inorder == null || lastorder.length == 0)
            return null;
        // 前序节点和中序数组长度相同
        if (lastorder.length != inorder.length)
            throw new Exception("parameter error!");
        int len = inorder.length;
        Node root = new Node(lastorder[len - 1]);
        int i = 0;
        while (i < len) {
            if (inorder[i] == lastorder[len - 1])
                break;
            i++;
        }
        root.leftChild = createNewTreeByML(Arrays.copyOfRange(inorder, 0, i), Arrays.copyOfRange(lastorder, 0, i));
        root.rightChild = createNewTreeByML(Arrays.copyOfRange(inorder, i + 1, len),
                Arrays.copyOfRange(lastorder, i, len - 1));
        return root;

    }

    // 根据先序遍历结果和中续遍历结果创建一个二叉树，并返回该二叉树的root节点
    public static Node createNewTreeByFM(int[] preorder, int[] inorder) throws Exception {
        // 如果二叉树的前序数组长度为0，是不用返回一个空节点的，直接返回null，说明该节点没有左孩子或者右孩子
        if (preorder == null || inorder == null || preorder.length == 0)
            return null;
        // 前序节点和中序数组长度相同
        if (preorder.length != inorder.length)
            throw new Exception("parameter error!");
        Node root = new Node(preorder[0]);
        int len = inorder.length;
        int i = 0;
        while (i < len) {
            // 在循环中只要找到中序遍历的位置即可
            if (inorder[i] == preorder[0])
                break;
            i++;
        }
        root.leftChild = createNewTreeByFM(Arrays.copyOfRange(preorder, 1, i + 1), Arrays.copyOfRange(inorder, 0, i));
        root.rightChild = createNewTreeByFM(Arrays.copyOfRange(preorder, i + 1, len),
                Arrays.copyOfRange(inorder, i + 1, len));
        return root;
    }

    // 根据一个数组创建一个2叉树
    private void createBinTree(int[] array) {
        if (array == null || array.length == 0)
            return;
        List<Node> nodeList = new LinkedList<Node>();
        // 将一个数组的值依次转换为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).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);
        }
        root = nodeList.get(0);
    }

    public Node getRoot() {
        return root;
    }

    /**
     * 先序遍历 这三种不同的遍历结构都是一样的，只是先后顺序不一样而已
     * @param node遍历的节点
     */
    public static void preOrderTraverse(Node node) {
        if (node == null)
            return;
        System.out.print(node.data + " ");
        preOrderTraverse(node.leftChild);
        preOrderTraverse(node.rightChild);
    }

    /**
     * 中序遍历 这三种不同的遍历结构都是一样的，只是先后顺序不一样而已
     * 
     * @param node
     *            遍历的节点
     */
    public static void middleOrderTraverse(Node node) {
        if (node == null)
            return;
        middleOrderTraverse(node.leftChild);
        System.out.print(node.data + " ");
        middleOrderTraverse(node.rightChild);
    }

    /**
     * 后序遍历 这三种不同的遍历结构都是一样的，只是先后顺序不一样而已
     * 
     * @param node
     *            遍历的节点
     */
    public static void lastOrderTraverse(Node node) {
        if (node == null)
            return;
        lastOrderTraverse(node.leftChild);
        lastOrderTraverse(node.rightChild);
        System.out.print(node.data + " ");
    }

    /**
     * 遍历树
     * @param root
     */
    public static void showResult(Node root) {
        System.out.println("先序遍历:");
        preOrderTraverse(root);
        System.out.println();
        System.out.println("中序遍历:");
        middleOrderTraverse(root);
        System.out.println();
        System.out.println("后序遍历:");
        lastOrderTraverse(root);
        System.out.println();
    }

    public static void main(String[] args) throws Exception {
//      根据该数组创建二叉树
        int[] array = {1,2,3,4,5,6,7,8,9};
        BinaryTree bt = new BinaryTree(array);
        Node r = bt.getRoot();
        showResult(r);
//      前序
        int[] preorder = { 1, 2, 4, 7, 3, 5, 6, 8 };
//      中序
        int[] inorder = { 4, 7, 2, 1, 5, 3, 8, 6 };
//      后序
        int[] lastorder = { 7, 4, 2, 5, 8, 6, 3, 1 };
//      前中求后
        Node root = createNewTreeByFM(preorder, inorder);
//      中后求前
        Node root2 = createNewTreeByML(inorder, lastorder);

        showResult(root);
        showResult(root2);


    }

}