根据前序遍历和中序遍历重建二叉树以及树的遍历

import datastructure.TreeNode;

import java.util.LinkedList;

public class Mian {
    public static void main(String[] args) {
        int pre[] = {1, 2, 4, 7, 3, 5, 6, 8};
        int in[] = {4, 7, 2, 1, 5, 3, 8, 6};
        TreeNode tree = buildTree(pre, in);
        firstPrint(tree);
        System.out.println();
        levelPrint(tree);
    }

    /**
     * 二叉树前序遍历
     *
     * @param treeNode
     */
    public static void firstPrint(TreeNode treeNode) {
        if (treeNode == null) {
            return;
        }
        System.out.print(treeNode.val + " ");
        firstPrint(treeNode.left);
        firstPrint(treeNode.right);
    }

    /**
     * 二叉树层次遍历
     *
     * @param treeNode
     */
    public static void levelPrint(TreeNode treeNode) {
        if (treeNode == null) {
            return;
        }
        LinkedList<TreeNode> queue = new LinkedList<>();
        TreeNode current = null;
        queue.offer(treeNode); // 根节点入队
        while (!queue.isEmpty()) {
            current = queue.poll(); // 出队
            System.out.print(current.val + " ");
            if (current.left != null) { // 左右入队
                queue.offer(current.left);
            }
            if (current.right != null) {
                queue.offer(current.right);
            }
        }
    }

    /**
     * 根据前序遍历和中序遍历重建二叉树
     *
     * @param pre
     * @param in
     * @return
     */
    public static TreeNode buildTree(int pre[], int in[]) {
        if (pre == null || pre.length == 0) {
            return null;
        }
        TreeNode treeNode = new TreeNode(pre[0]); // 先找到根节点
        int length = pre.length; // 记录数组长度
        if (length == 1) { // 边界条件（只有根节点）
            treeNode.left = null;
            treeNode.right = null;
            return treeNode;
        }

        int flag = 0;
        for (int i = 0; i < length; i++) { // 找到根节点在中序遍历中的位置
            if (pre[0] == in[i]) {
                flag = i;
                break;
            }
        }

        /**
         * 重建左子树
         */
        if (flag > 0) {
            int leftPre[] = new int[flag]; // 左子树的先序
            int leftIn[] = new int[flag]; // 左子树的中序
            for (int i = 0; i < flag; i++) {
                leftPre[i] = pre[i + 1]; // 不包括根节点
                leftIn[i] = in[i];
            }
            treeNode.left = buildTree(leftPre, leftIn);
        } else {
            treeNode.left = null;
        }

        /**
         * 重建右子树（length-左树-根节点）
         */
        if (length - flag > 1) {
            int rightPre[] = new int[length - flag - 1]; // 右子树的先序
            int rightIn[] = new int[length - flag - 1]; // 右子树的中序
            for (int i = flag + 1; i < length; i++) {
                rightPre[i - flag - 1] = pre[i];
                rightIn[i - flag - 1] = in[i];
            }
            treeNode.right = buildTree(rightPre, rightIn);
        } else {
            treeNode.right = null;
        }

        return treeNode;
    }
}