树-构建二叉树

link:https://leetcode-cn.com/problems/zhong-jian-er-cha-shu-lcof

输入某二叉树的前序遍历和中序遍历的结果，请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。
例如，给出

前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]
返回如下的二叉树：

    3
   /   9  20
    /  \         
   15   7

# 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            
        r = TreeNode(preorder[0])               
        rid = inorder.index(preorder[0])        
        r.left = self.buildTree(preorder[1:1+rid], inorder[:rid])     
        r.right = self.buildTree(preorder[rid+1:], inorder[rid+1:])   
        return r

105. 从前序与中序遍历序列构造二叉树
根据一棵树的前序遍历与中序遍历构造二叉树。

注意:
你可以假设树中没有重复的元素。

例如，给出

前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]
返回如下的二叉树：

    3
   /   9  20
    /     15   7



# 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 or not inorder:  # 递归终止条件
            return
        root = TreeNode(preorder[0])  
        # 先序为“根左右”，所以根据preorder可以确定root
        idx = inorder.index(preorder[0])  
        # 中序为“左根右”，根据root可以划分出左右子树
        # 下面递归对root的左右子树求解即可
        root.left = self.buildTree(preorder[1:1 + idx], inorder[:idx])
        root.right = self.buildTree(preorder[1 + idx:], inorder[idx + 1:])
        return root


class Solution:
    def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
        if not preorder:
            return None

        root = TreeNode(preorder[0])
        stack = [root]
        inorderIndex = 0
        for i in range(1, len(preorder)):
            preorderVal = preorder[i]
            node = stack[-1]
            if node.val != inorder[inorderIndex]:
                node.left = TreeNode(preorderVal)
                stack.append(node.left)
            else:
                while stack and stack[-1].val == inorder[inorderIndex]:
                    node = stack.pop()
                    inorderIndex += 1
                node.right = TreeNode(preorderVal)
                stack.append(node.right)

        return root

106. 从中序与后序遍历序列构造二叉树
根据一棵树的中序遍历与后序遍历构造二叉树。

注意:
你可以假设树中没有重复的元素。

例如，给出

中序遍历 inorder = [9,3,15,20,7]
后序遍历 postorder = [9,15,7,20,3]
返回如下的二叉树：

    3
   /   9  20
    /     15   7



 class Solution(object):
    def buildTree(self, inorder, postorder):
        if not (inorder and postorder):
            return None
        def helper(inor,post):
            if not post:
                return None
            # 根据后序数组的最后一个元素，创建根节点    
            root = TreeNode(post[-1])
            # 在中序数组中查找值等于【后序数组最后一个元素】的下标
            idx = inor.index(post[-1])
            # 确定这个下标i后，将中序数组分成两部分，后序数组分成两部
            # 递归处理中序数组左边，后序数组左边
            # 递归处理中序数组右边，后序数组右边
            root.left = helper(inor[:idx],post[:idx])
            root.right = helper(inor[idx+1:],post[idx:-1])
            return root
        return helper(inorder,postorder)