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 3
about 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:
- We guarantee the recursion
preorder
andinorder
the number is the same - Every time
index
; so wemap
save 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;
}
}