【NO.43】LeetCode HOT 100—105. 从前序与中序遍历序列构造二叉树

105. 从前序与中序遍历序列构造二叉树

105. 从前序与中序遍历序列构造二叉树
给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。

示例 1:

输入: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
输出: [3,9,20,null,null,15,7]
示例 2:

输入: preorder = [-1], inorder = [-1]
输出: [-1]

提示:

1 <= preorder.length <= 3000
inorder.length == preorder.length
-3000 <= preorder[i], inorder[i] <= 3000
preorder 和 inorder 均 无重复 元素
inorder 均出现在 preorder
preorder 保证 为二叉树的前序遍历序列
inorder 保证 为二叉树的中序遍历序列

解题

方法：深度优先遍历

二叉树前序遍历的顺序为：

• 先遍历根节点；

• 随后递归地遍历左子树；

• 最后递归地遍历右子树。

二叉树中序遍历的顺序为：

• 先递归地遍历左子树；

• 随后遍历根节点；

• 最后递归地遍历右子树。

在「递归」地遍历某个子树的过程中，我们也是将这颗子树看成一颗全新的树，按照上述的顺序进行遍历。挖掘「前序遍历」和「中序遍历」的性质，我们就可以得出本题的做法。

时间复杂度，空间复杂度都为O(n)

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {

    // key 是中序遍历中的值，value是对应的下标
    HashMap<Integer, Integer> map = new HashMap<>();

    public TreeNode buildTree(int[] preorder, int[] inorder) {
        // 先把中序遍历的值放进map
        for (int i = 0; i < inorder.length; i++) {
            map.put(inorder[i], i);
        }
        int length = preorder.length;

        // 然后进入递归，开始找寻各个根节点
        return dfs(preorder, inorder, 0, length-1, 0, length-1);
    }

    // 参数含义：两个数组，第一个数组的左右边界，第二个数组的左右边界
    private TreeNode dfs (int[] preorder, int[] inorder,
                            int preLeft, int preRight,
                            int inLeft, int inRight) {
        if (preLeft > preRight) {
            return null;
        }

        // 根节点 就是 前序遍历数组的第一个数
        TreeNode root = new TreeNode(preorder[preLeft]);
        // 找到这个数在中序数组中的位置，这个位置前面就是左子树的返回，右边就是右子树的范围
        int inRootIndex = map.get(preorder[preLeft]);
        // 左子树的范围大小
        int leftTreeIndex = inRootIndex - inLeft;

        // 找root 的左子树的根节点，就要传对应的数组下标范围
        root.left = dfs(preorder, inorder, 
                        preLeft+1, preLeft+leftTreeIndex,
                        inLeft, inRootIndex-1);
        //  找root 的右子树的根节点，就要传对应的数组下标范围
        root.right = dfs(preorder, inorder, 
                        preLeft+leftTreeIndex+1, preRight,
                        inRootIndex+1, inRight);
    
        return root;

    }
}