重键二叉树 (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:
        def dfsBuild(left, right):
            if left > right:
                return None
            val = preorder.pop(0)
            indexroot = index[val]
            root = TreeNode(val)
            root.left = dfsBuild(left, indexroot-1)
            root.right = dfsBuild(indexroot+1, right)
            return root
        index = {element:i for i, element in enumerate(inorder)}
        return dfsBuild(0, len(preorder)-1)

# 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 not preorder:
            return None
        root = TreeNode(preorder[0])
        stack = [root]
        indexinorder = 0
        for i in range(1, len(preorder)):
            preorderval = preorder[i]
            node = stack[-1]
            if node.val != inorder[indexinorder]:
                node.left = TreeNode(preorderval)
                stack.append(node.left)
            else:
                while stack and stack[-1].val == inorder[indexinorder]:
                    node = stack.pop()
                    indexinorder += 1
                node.right = TreeNode(preorderval)
                stack.append(node.right)
        return root

# 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, inorder: List[int], postorder: List[int]) -> TreeNode:
        def myBuidTree(left, right):
            if left > right:
                return None
            val = postorder.pop()
            root = TreeNode(val)
            rootindex = index[val]
            root.right = myBuidTree(rootindex+1, right)
            root.left = myBuidTree(left,rootindex-1)
            return root
        index = {element:i for i, element in enumerate(inorder)}
        return myBuidTree(0, len(inorder)-1)

# 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, inorder: List[int], postorder: List[int]) -> TreeNode:
        if not inorder:
            return None
        root = TreeNode(postorder[-1])
        stack = [root]
        inorderindex = len(inorder)-1
        for i in range(len(postorder)-2,-1,-1):
            postorderval = postorder[i]
            node = stack[-1]
            if node.val != inorder[inorderindex]:
                node.right = TreeNode(postorderval)
                stack.append(node.right)
            else:
                while stack and stack[-1].val == inorder[inorderindex]:
                    node = stack.pop()
                    inorderindex -= 1
                node.left = TreeNode(postorderval)
                stack.append(node.left)
        return root