105. 先序、中序构造树

---

Given preorder and inorder traversal of a tree, construct the binary tree.

Note:
You may assume that duplicates do not exist in the tree.

 

 

 

 

 

# 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 | None:
        
        def build(p1,p2,i1,i2):
            if p1 > p2 or i1 > i2:
                return None
            root = TreeNode(preorder[p1])
            i_new = i1
            while i_new <= i2:
                if preorder[p1]==inorder[i_new]:
                    break
                i_new+=1


            left_size = i_new-i1


            root.left = build(p1+1,p1+left_size, i1,i_new-1)
            root.right = build(p1+left_size+1,p2,i_new+1,i2)
            return root 
        n = len(preorder)
        return build(0,n-1,0,n-1)

 

 

 

def buildTree(self, preorder, inorder):
    pos = {v: i for i, v in enumerate(inorder)}   # 一次建表

    def build(pre_l, pre_r, in_l, in_r):
        if pre_l > pre_r:
            return None
        val = preorder[pre_l]
        node = TreeNode(val)
        k = pos[val] - in_l                 # 左子树节点数
        node.left  = build(pre_l + 1,     pre_l + k, in_l,     in_l + k - 1)
        node.right = build(pre_l + k + 1, pre_r,     in_l + k + 1, in_r)
        return node

    return build(0, len(preorder) - 1, 0, len(inorder) - 1)

 

class Solution:
    def buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:

        def build(preorder,inorder,pre_left,pre_right,in_left,in_right):
            if pre_right > len(preorder) or in_right > len(preorder):
                return None
            if in_left > in_right or pre_left > pre_right:
                return None
            val = preorder[pre_left]
            node = TreeNode(val)
            hd_index = inorder.index(val)
            left_cnt = hd_index - in_left
            right_cnt = in_right - hd_index
            node.left = build(preorder,inorder,pre_left+1,pre_left+left_cnt,in_left,in_left+left_cnt-1)
            node.right = build(preorder,inorder,pre_left+left_cnt+1,pre_right,in_left+left_cnt+1,in_right)
            return node
        n = len(preorder)
        return build(preorder,inorder,0,n-1,0,n-1)

 

 

 

class Solution {
private:
    unordered_map<int,int> index_map;
public:
    TreeNode* build(int pre_left,int pre_right, vector<int>& preorder, int in_left, int in_right,vector<int>& inorder) {
        if(pre_left > pre_right || in_left > in_right) return nullptr; 
        int inorder_index = index_map[preorder[pre_left]];
        int left_length = inorder_index  - in_left;
        TreeNode* root = new TreeNode(preorder[pre_left]);
        root->left = build(pre_left+1,pre_left+left_length,preorder,in_left,inorder_index-1,inorder);
        root->right= build(pre_left+left_length+1,pre_right,preorder,inorder_index+1,in_right,inorder);
        return root;
    }
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        for(int i = 0; i < inorder.size(); ++i) {
            index_map[inorder[i]] = i;
        }
        return build(0,preorder.size()-1,preorder,0,inorder.size()-1,inorder);
    }
};

 

 

 

 

class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        return help(preorder,0,preorder.length-1,inorder,0,inorder.length-1);
    }
    private TreeNode help(int[] preorder,int pre_start,int pre_end,int[] inorder,int in_start,int in_end){
        if(in_start>in_end || pre_start>pre_end) return null;
        
        
        TreeNode root = new TreeNode(preorder[pre_start]);
        int j = in_start;
        while(preorder[pre_start]!=inorder[j]&& j <=pre_end)
            j++;
        //注意下标！！！！！！！！
        root.left = help(preorder,pre_start+1,pre_start+(j-in_start),inorder,in_start,j-1);
        root.right = help(preorder,pre_start+(j-in_start)+1,pre_end,inorder,j+1,in_end);
        return root;
    }
}