剑指Offer之重建二叉树

题目描述

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

分析：

在二叉树的前序遍历中，第一个数字总是树的根节点的值。但在中序遍历序列中，根节点的值在序列的中间，左子树的值位于根节点的左边，而右子树的节点的值位于根节点的值得右边。因此我们需要扫描中序遍历，才能找到根节点的值。

如下图所示，前序遍历序列的第一个数字1就是根节点的值。扫描中序遍历序列，就能确定根节点的值得位置。根据中序遍历特点，在根节点的值1前面的3个数字都是左子树节点的值，位于1后面的数字都是右子树节点的值。

 由于在中序遍历中，有3个数字是左子树节点的值，因此左子树总共有3个左子节点。同样，在前序遍历中，根节点后面的3个数字就是3个左子树节点的值，再后面的所有数字都是右节点的值。这样我们就在前序遍历和中序遍历两个序列中，分别找到了左右子树对应的子序列。

Java代码

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

/**
 * Created by Feng on 2017/5/1.
 * 输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。
 * 例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
 */
public class ReConstructBinaryTree {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            int n = sc.nextInt();//二叉树的节点数

            int[] preorder = new int[n];//二叉树先序遍历
            for (int i = 0; i < n; i++) {
                preorder[i] = sc.nextInt();
            }

            int[] inorder = new int[n];//二叉树中序遍历
            for (int i = 0; i < n; i++) {
                inorder[i] = sc.nextInt();
            }

            TreeNode root = reConstruct(preorder, inorder);
            System.out.print(root.val + " ");

            //使用对列输出重构的二叉树
            Queue<TreeNode> queue = new LinkedList<>();
            queue.add(root);

            //利用对列先进先出的特点
            while (!queue.isEmpty()) {
                TreeNode node = queue.poll();
                if (node.left != null) {
                    System.out.print(node.left.val + " ");
                    queue.add(node.left);
                }
                if (node.right != null) {
                    System.out.print(node.right.val + " ");
                    queue.add(node.right);
                }
            }
        }
    }

    private static TreeNode reConstruct(int[] preorder, int[] inorder) {
        if (preorder == null || inorder == null) {
            return null;
        }

        return reConstructCore(preorder, 0, preorder.length - 1, inorder, 0, inorder.length - 1);
    }

    private static TreeNode reConstructCore(int[] preorder, int startPre, int endPre,
                                            int[] inorder, int startIn, int endIn) {
        if (startPre > endPre || startIn > endIn) {
            return null;
        }

        //获取根节点，先序遍历的第一个值即根节点
        TreeNode root = new TreeNode(preorder[startPre]);

        for (int i = startIn; i <= endIn; i++) {
            if (inorder[i] == preorder[startPre]) {
                //构建左子树
                root.left = reConstructCore(preorder, startPre + 1, startPre + i - startIn,
                        inorder, startIn, i - 1);
                //构建右子树
                root.right = reConstructCore(preorder, i - startIn + startPre + 1, endPre,
                        inorder, i + 1, endIn);
            }
        }

        return root;
    }


}

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode(int x) {
        val = x;
    }
}