重建二叉树

输入某二叉树的前序遍历和中序遍历的结果，请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。

例如，给出

前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]

返回如下的二叉树：

    3
   / 
  9  20
    /  
   15   7

限制：

0 <= 节点个数 <= 5000

题解1：分治法（递归思想）

　　思路：

　　前序遍历的第 1 个结点一定是二叉树的根结点；
　　在中序遍历中，根结点把中序遍历序列分成了两个部分，左边部分构成了二叉树的根结点的左子树，右边部分构成了二叉树的根结点的右子树。
　　查找根结点在中序遍历序列中的位置，可以遍历，也可以在一开始就记录下来。

import java.util.HashMap;
import java.util.Map;

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

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


public class Solution {

    // 使用全局变量是为了让递归方法少传一些参数，不一定非要这么做

    private Map<Integer, Integer> reverses;
    private int[] preorder;

    public TreeNode buildTree(int[] preorder, int[] inorder) {
        int preLen = preorder.length;
        int inLen = inorder.length;

        // 可以不做判断，因为题目中给出的数据都是有效的
        if (preLen != inLen) {
            return null;
        }

        this.preorder = preorder;

        // 以空间换时间，否则，找根结点在中序遍历中的位置需要遍历
        reverses = new HashMap<>(inLen);
        for (int i = 0; i < inLen; i++) {
            reverses.put(inorder[i], i);
        }

        return buildTree(0, preLen - 1, 0, inLen - 1);
    }

    /**
     * 根据前序遍历数组的 [preL, preR] 和 中序遍历数组的 [inL, inR] 重新组建二叉树
     *
     * @param preL 前序遍历数组的区间左端点
     * @param preR 前序遍历数组的区间右端点
     * @param inL  中序遍历数组的区间左端点
     * @param inR  中序遍历数组的区间右端点
     * @return 构建的新二叉树的根结点
     */
    private TreeNode buildTree(int preL, int preR,
                               int inL, int inR) {
        if (preL > preR || inL > inR) {
            return null;
        }
        // 构建的新二叉树的根结点一定是前序遍历数组的第 1 个元素
        int pivot = preorder[preL];
        TreeNode root = new TreeNode(pivot);

        int pivotIndex = reverses.get(pivot);

        // 这一步得画草稿，计算边界的取值，必要时需要解方程，并不难
        root.left = buildTree(preL + 1, preL + (pivotIndex - inL), inL, pivotIndex - 1);
        root.right = buildTree(preL + (pivotIndex - inL) + 1, preR, pivotIndex + 1, inR);
        return root;
    }
}

题解2：

　　递归解析：
　　递推参数： 前序遍历中根节点的索引pre_root、中序遍历左边界in_left、中序遍历右边界in_right。
　　终止条件： 当 in_left > in_right ，子树中序遍历为空，说明已经越过叶子节点，此时返回 nullnull 。

　　递推工作：
　　1.建立根节点root： 值为前序遍历中索引为pre_root的节点值。
　　2.搜索根节点root在中序遍历的索引i： 为了提升搜索效率，本题解使用哈希表 dic 预存储中序遍历的值与索引的映射关系，每次搜索的时间复杂度为 O(1)O(1)。
　　3.构建根节点root的左子树和右子树： 通过调用 recur() 方法开启下一层递归。
　　　　左子树： 根节点索引为 pre_root + 1 ，中序遍历的左右边界分别为 in_left 和 i - 1。
　　　　右子树： 根节点索引为 i - in_left + pre_root + 1（即：根节点索引 + 左子树长度 + 1），中序遍历的左右边界分别为 i + 1 和 in_right。
　　4.返回值： 返回 root，含义是当前递归层级建立的根节点 root 为上一递归层级的根节点的左或右子节点。

class Solution {
    HashMap<Integer, Integer> dic = new HashMap<>();
    int[] po;
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        po = preorder;
        for(int i = 0; i < inorder.length; i++) 
            dic.put(inorder[i], i);
        return recur(0, 0, inorder.length - 1);
    }
    TreeNode recur(int pre_root, int in_left, int in_right) {
        if(in_left > in_right) return null;
        TreeNode root = new TreeNode(po[pre_root]);
        int i = dic.get(po[pre_root]);
        root.left = recur(pre_root + 1, in_left, i - 1);
        root.right = recur(pre_root + i - in_left + 1, i + 1, in_right);
        return root;
    }
}

题解3：

class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        return buildTree(preorder, 0, preorder.length - 1, inorder, 0, inorder.length - 1);
    }
    
    /**
     * preStart - preEnd 代表了在 preorder[] 中查找的区间范围
     * inStart - inEnd   代表了在 inorder[]  中查找的区间范围
     */
    private TreeNode buildTree(int[] preorder, int preStart, int preEnd
                            , int[] inorder, int inStart, int inEnd) {
        // 显而易见的结束条件
        if (preStart > preEnd || inStart > inEnd) {
            return null;
        }
        // 前序遍历的第一个节点为 root
        TreeNode root = new TreeNode(preorder[preStart]);
        
        // 在中序遍历的查找区间中找到 root 所处位置
        for (int i = inStart; i <= inEnd; i++) {

            if (inorder[i] == preorder[preStart]) {
                // 前序区间的 start 从根节点后一位开始
                // 前序区间的 end 是中序遍历确定的左子树节点个数 + 原先的preStart
                // 中序区间的 start 不变，因为从头开始找左子树
                // 中序区间的 end 最多达到当前根节点的前一位
                root.left = buildTree(preorder, preStart + 1, i - inStart + preStart
                                    , inorder, inStart, i - 1);

                // 前序区间的 start 从当前根节点跳过左子树个数开始
                // 前序区间的 end 保持不变，扫描到底
                // 中序区间的 start 从根节点的后一位开始
                // 中序区间的 end 保持不变
                root.right = buildTree(preorder, i - inStart + preStart + 1, preEnd
                                    , inorder, i + 1, inEnd);
            }
        }
        return root;
    }
}

题解4：

使用Arrays.copyOfRange（）方法

class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        int n = preorder.length;
        if (n == 0)
            return null;
        int rootVal = preorder[0], rootIndex = 0;
        for (int i = 0; i < n; i++) {
            if (inorder[i] == rootVal) {
                rootIndex = i;
                break;
            }
        }
        TreeNode root = new TreeNode(rootVal);
        
        root.left = buildTree(Arrays.copyOfRange(preorder, 1, 1 + rootIndex),Arrays.copyOfRange(inorder, 0, rootIndex));

        root.right = buildTree(Arrays.copyOfRange(preorder, 1 + rootIndex, n),Arrays.copyOfRange(inorder, rootIndex + 1, n));

        return root;
    }
}

来源：https://leetcode-cn.com/problems/zhong-jian-er-cha-shu-lcof/