从前序和中序遍历序列构建二叉树
该博客为学习文档,递归方法:
C++
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
private:
unordered_map<int, int> index;
public:
TreeNode* mybuildTree(const vector<int>& preorder, const vector<int>& inorder, int preorder_left, int preorder_right, int inorder_left, int inorder_right){
if (preorder_left > preorder_right){
return nullptr;
}
int preorder_root = preorder_left;
int inorder_root = index[preorder[preorder_root]];
TreeNode* root = new TreeNode(preorder[preorder_root]);
int left_subtree_size = inorder_root - inorder_left;
root->left = mybuildTree(preorder, inorder, preorder_left+1, preorder_left+left_subtree_size, inorder_left, inorder_root-1);
root->right = mybuildTree(preorder, inorder, preorder_left+left_subtree_size+1, preorder_right, inorder_root+1, inorder_right);
return root;
}
TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder){
int n = preorder.size();
for (int i = 0; i<n; ++i){
index[inorder[i]] = i;
}
return mybuildTree(preorder, inorder, 0, n-1, 0, n-1);
}
};
Java
/**
* 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 {
private TreeNode mybuildTree(int[] preorder, int[] inorder, int pre_start, int pre_end, int in_start, int in_end, Map<Integer, Integer> in_map) {
if (pre_start>pre_end || in_start> in_end) return null;
TreeNode root = new TreeNode(preorder[pre_start]);
int in_root = in_map.get(root.val);
int left_subtree_size = in_root - in_start;
root.left = mybuildTree(preorder, inorder, pre_start+1, pre_start+left_subtree_size, in_start, in_root-1, in_map);
root.right = mybuildTree(preorder, inorder, pre_start+left_subtree_size+1, pre_end, in_root+1, in_end, in_map);
return root;
}
public TreeNode buildTree(int[] preorder, int[] inorder){
HashMap<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < inorder.length; ++i){
map.put(inorder[i], i);
}
return mybuildTree(preorder, inorder, 0, preorder.length-1, 0, inorder.length-1, map);
}
}
Python
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
if len(inorder) == 0:
return None
idx_root = inorder.index(preorder[0])
root = TreeNode(preorder[0])
root.left = self.buildTree(preorder[1:idx_root+1], inorder[:idx_root])
root.right = self.buildTree(preorder[idx_root+1:], inorder[idx_root+1:])
return root