LeetCode 105. Construct Binary Tree from Preorder and Inorder Traversal

Problem

LeetCode 105. Construct Binary Tree from Preorder and Inorder Traversal

1. 题目简述

给出一棵树的前序遍历和中序遍历的顺序，恢复这棵树。例如：

For example, given
preorder = [3,9,20,15,7]
inorder = [9,3,15,20,7]

Return the following binary tree:
     3
    / \
   9  20
    /  \
   15   7

2. 算法思路

DFS

这道题和LeetCode 106很像，只不过106是给出中序遍历和后序遍历，要求恢复整棵树。

先拿这道题来说，先序遍历的顺序是“中->左->右”，也就是说第一个元素是整棵树的根节点，后面是它的左子树和右子树的节点，但是我们不知道哪些是左子树，哪些是右子树。因此我们需要借助中序遍历，中序遍历的顺序是“左->中->右”，找到根节点后，中序遍历数组中，根节点左侧的节点就是其左子树的所有节点，右侧就是其右子树的所有节点；至此，我们知道了左子树的节点个数l和右子树节点个数r，前序遍历中第1到l个元素就是根节点左子树的前序遍历的顺序，右子树同理，随后递归构建其左右子树。

3. 解法（LeetCode 105 & 106）

1. LeetCode 105 preorder + inorder

使用Arrays.copyOfRange(int[] data, int start, int end)函数，写起来简洁，但是有点慢，而且耗空间大，因为要截取数组。

class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        int length = preorder.length;
        if (length == 0) {
            return null;
        }

        int rootVal = preorder[0];
        int rootIndex = 0;

        for (int i = 0; i < length; i++) {
            if (inorder[i] == rootVal) {
                rootIndex = i;
                break;
            }
        }

        TreeNode root = new TreeNode(rootVal);
        root.left = buildTree(Arrays.copyOfRange(preorder, 1, rootIndex + 1), Arrays.copyOfRange(inorder, 0, rootIndex));
        root.right = buildTree(Arrays.copyOfRange(preorder, rootIndex + 1, length), Arrays.copyOfRange(inorder, rootIndex + 1, length));

        return root;
    }
}

2. LeetCode 106 postorder + inorder

第二种方式可以重新构建一个函数，直接传入原始的两个数组，以及其对应的start和end，以及一个用于查找目标value的map，且代码也更加复杂，涉及到的变量很多，但是速度相对更快一点。

/**
 * 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;
 *     }
 * }
 */
c/**
 * 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 {
public TreeNode buildTree(int[] preorder, int[] inorder) {
    Map<Integer, Integer> inMap = new HashMap<Integer, Integer>();
    
    for(int i = 0; i < inorder.length; i++) {
        inMap.put(inorder[i], i);
    }

    TreeNode root = buildTree(preorder, 0, preorder.length - 1, inorder, 0, inorder.length - 1, inMap);
    return root;
}

public TreeNode buildTree(int[] preorder, int preStart, int preEnd, int[] inorder, int inStart, int inEnd, Map<Integer, Integer> inMap) {
    if(preStart > preEnd || inStart > inEnd) return null;
    
    TreeNode root = new TreeNode(preorder[preStart]);
    int inRoot = inMap.get(root.val);
    int numsLeft = inRoot - inStart;
    
    root.left = buildTree(preorder, preStart + 1, preStart + numsLeft, inorder, inStart, inRoot - 1, inMap);
    root.right = buildTree(preorder, preStart + numsLeft + 1, preEnd, inorder, inRoot + 1, inEnd, inMap);
    
    return root;
}
}