剑指offer4--重建二叉树

输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */

/**
 * Created by dell on 2018/1/13.
 * 输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。
 * 假设输入的前序遍历和中序遍历的结果中都不含重复的数字。
 * 例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
 * <p>
 * <p>
 * 前序：根左右
 * 中序：左根右
 * 后序：左右根
 */
public class RebuildBinaryTree {
    public static void main(String[] args) {
        int pre[] = {1, 2, 3, 4, 5, 6, 7};
        int in[] = {3, 2, 4, 1, 6, 5, 7};
        TreeNode tree = reConstructBinaryTreeTest(pre, in);
        System.out.println("tree.root=" + tree.val);
        System.out.print("先序遍历结果:  {");
        preTraverseBinTree(tree);
        System.out.println("}");
        System.out.print("中序遍历结果:  {");
        inTraverseBinTree(tree);
        System.out.println("}");
        System.out.print("后序遍历结果:  {");
        postTraverseBinTree(tree);
        System.out.println("}");
        System.out.print("按层打印结果:  {");
        levelTravel(tree);
        System.out.println("}");
    }


    private static TreeNode reConstructBinaryTreeTest(int[] pre, int[] in) {
        if (pre == null || in == null) {
            return null;
        }
        TreeNode tm = reConstructBinaryTree(pre, in, 0, pre.length - 1, 0, in.length - 1);
        return tm;
    }


    public static TreeNode reConstructBinaryTree(int[] pre, int in[], int preStart, int preEnd, int inStart, int inEnd) {
        TreeNode tree = new TreeNode(pre[preStart]);
        tree.left = null;
        tree.right = null;
        if (preStart == preEnd && inStart == inEnd) {
            return tree;
        }
        int root = 0;
        //找到中序遍历中根节点的位置
        for (root = inStart; root < inEnd; root++) {
            if (pre[preStart] == in[root]) {
                System.out.println("root=" + root);
                System.out.println("root val=" + in[root]);
                break;

            }
        }
        int leftLength = root - inStart;
        int rightLength = inEnd - root;

        if (leftLength > 0) {
            tree.left = reConstructBinaryTree(pre, in, preStart + 1, preStart + leftLength, inStart, root - 1);
        }
        if (rightLength > 0) {
            tree.right = reConstructBinaryTree(pre, in, preStart + 1 + leftLength, preEnd, root + 1, inEnd);
        }
        return tree;
    }

    //先序遍历 根左右
    public static void preTraverseBinTree(TreeNode node) {
        if (node == null) {
            return;
        }
        System.out.print(node.val + ",");
        if (node.left != null) {
            preTraverseBinTree(node.left);
        }
        if (node.right != null) {
            preTraverseBinTree(node.right);
        }
    }

    //中序遍历 左根右
    public static void inTraverseBinTree(TreeNode node) {
        if (node == null) {
            return;
        }
        if (node.left != null) {
            inTraverseBinTree(node.left);
        }
        System.out.print(node.val + ",");
        if (node.right != null) {
            inTraverseBinTree(node.right);
        }
    }

    //后续遍历 左右根
    public static void postTraverseBinTree(TreeNode node) {
        if (node == null) {
            return;
        }
        if (node.left != null) {
            inTraverseBinTree(node.left);
        }
        if (node.right != null) {
            inTraverseBinTree(node.right);
        }
        System.out.print(node.val + ",");
    }

    //按层打印二叉树
    public static void levelTravel(TreeNode root) {
        if (root == null) return;
        Queue<TreeNode> q = new LinkedList<TreeNode>();
        q.offer(root);//添加一个元素并返回true
        while (!q.isEmpty()) {
            TreeNode temp = q.poll();//移除并返回队列头部的元素，如果队列为空，返回null
            System.out.print(temp.val + " ");
            if (temp.left != null) q.offer(temp.left);
            if (temp.right != null) q.offer(temp.right);
        }
    }

}