[LeetCode] 105. previous order and a binary tree configuration sequence preorder

Topic links: https://leetcode-cn.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/

Subject description:

Traversing the binary tree is configured in accordance with the sequence preorder traversal of a tree.

Note:
You can assume that the tree does not duplicate elements.

For example, given

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

Returns the following binary tree:

    3
   / \
  9  20
    /  \
   15   7

Ideas:

This question and the sequence 106. therefrom sequence preorder with the binary tree structure is the same

We want to know, preorder traversal is: root -> Left -> Right; preorder is: Left -> root -> Right

So we can order traversal through the tree can be divided into left and right portions.

For example example, the preorder traversal 3, then the node 3about sub-tree [9]; [15,20,7]and then we recursion, the following simple idea

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
        if not preorder:return None
        root = TreeNode(preorder[0])
        loc = inorder.index(preorder[0])
        root.left = self.buildTree(preorder[1 : loc + 1], inorder[ : loc])
        root.right = self.buildTree(preorder[loc+1 : ], inorder[loc+1: ])
        return root

note:

1. We guarantee the recursion preorderand inorderthe number is the same
2. Every time index; so we mapsave time.

Code annotated, well understood!

Code:

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
        from collections import defaultdict
        n = len(preorder)
        inorder_map = defaultdict(int)
        for idx, val in enumerate(inorder):
            inorder_map[val] = idx

        def helper(pre_start, pre_end, in_start, in_end):
            if pre_start == pre_end:
                return None
            root = TreeNode(preorder[pre_start])
            loc = inorder_map[preorder[pre_start]]
            # 这里要注意 因为 一开始可以明确是 pre_start + 1,in_start,loc,因为前序和中序个数是相同,所以可以求出前序左右边界
            root.left = helper(pre_start + 1, pre_start + 1 + loc - in_start, in_start, loc)
            # 根据上面用过的, 写出剩下就行了
            root.right = helper(pre_start + 1 + loc - in_start, pre_end, loc + 1, in_end)
            return root

        return helper(0, n, 0, n)

java

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        Map<Integer, Integer> inorder_map = new HashMap<>();
        int n = inorder.length;
        for (int i = 0; i < n; i++) inorder_map.put(inorder[i], i);

        return helper(preorder, 0, n, inorder, 0, n, inorder_map);


    }

    private TreeNode helper(int[] preorder, int pre_start, int pre_end, int[] inorder, int in_start, int in_end, Map<Integer, Integer> inorder_map) {
        if (pre_start == pre_end) return null;
        TreeNode root = new TreeNode(preorder[pre_start]);
        int loc = inorder_map.get(preorder[pre_start]);
        root.left = helper(preorder, pre_start + 1, pre_start + 1 + loc - in_start, inorder, in_start, loc, inorder_map);
        root.right = helper(preorder, pre_start + 1 + loc - in_start, pre_end, inorder, loc + 1, in_end, inorder_map);
        return root;
    }
}