pat根据中序遍历和先序遍历_LeetCode玩家 之 根据遍历还原二叉树

1. 根据前序遍历还原二叉树

1028. 从先序遍历还原二叉树

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

class Solution(object):
    def recoverFromPreorder(self, S):
        tree={}
        pos =0 
        while pos < len(S):
            depth = 0
            val = ''
            while S[pos]=='-':
                depth +=1
                pos +=1
            while pos< len(S) and S[pos]!='-':
                val += S[pos]
                pos +=1 
            if depth ==0:
                tree[0] = TreeNode(int(val))
            else:
                tree[depth] = TreeNode(int(val))
                if not tree[depth-1].left:
                    tree[depth-1].left = tree[depth]
                else:
                    tree[depth-1].right = tree[depth]
        return tree[0] if tree else None
    

2. 根据先序遍历还原二叉树

1008. 先序遍历构造二叉树

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def bstFromPreorder(self, preorder):
        if preorder:
            root = TreeNode(preorder.pop(0))
            l,r =[],[]
            for i in preorder:
                if i < root.val:
                    l +=[i]
                else:
                    r +=[i]
            root.left = self.bstFromPreorder(l)
            root.right = self.bstFromPreorder(r)
            return root

3. 根据前序和中序还原二叉树

105. 从前序与中序遍历序列构造二叉树

class Solution(object):
    def buildTree(self, preorder, inorder):
        if not preorder:
            return None

        root = TreeNode(preorder[0])
        index = inorder.index(preorder[0])

        root.left = self.buildTree(preorder[1:index+1],inorder[:index])
        root.right = self.buildTree(preorder[index+1:],inorder[index+1:])

        return root 

4. 根据中序和后续遍历还原二叉树

106. 从中序与后序遍历序列构造二叉树

class Solution(object):
    def buildTree(self, inorder, postorder):
        if not inorder:
           return None

        root = TreeNode(postorder[-1])
        index = inorder.index(postorder[-1])

        root.left = self.buildTree(inorder[:index],postorder[:index])
        root.right = self.buildTree(inorder[index+1:],postorder[index:-1])

        return root

5. 根据前序后续遍历还原二叉树

889. 根据前序和后序遍历构造二叉树

class Solution(object):
    def constructFromPrePost(self, pre, post):
        if not post:
            return

        root = TreeNode(pre[0])
        if len(post)==1: return root
        index = post.index(pre[1])

        root.left  = self.constructFromPrePost(pre[1:1+index+1],post[:index+1])
        root.right = self.constructFromPrePost(pre[1+index+1:],post[index+1:-1])

        return root