从二叉树的前、中、后序遍历中构造二叉树及python实现。leetcode105、leetcode106、leetcode889（python题解）

问题：从二叉树的前、中、后遍历中构造二叉树及其python实现，整理了当模板。对遍历顺序疑惑的推荐另一个博主的文章：

N叉树的前中后序的遍历顺序介绍

一、从前序与中序遍历序列构造二叉树(leetcode105)
问题：

题目来源：力扣（LeetCode）

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

难度：中等

分析：
前序遍历的第一个节点是根节点，从中序遍历中找到根节点的位置，得到左树和右树的大小，在前序遍历序列中找到左树和右树。如此循环。

解决方法：
1：递归

#递归
#超99%
# 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:
        def myBuildTree(preorder_left, preorder_right, inorder_left, inorder_right):
            if preorder_left > preorder_right: return 
            preorder_root = preorder_left
            inorder_root = index[preorder[preorder_root]]
            root = TreeNode(preorder[preorder_root])
            size_left_subtree = inorder_root - inorder_left
            root.left = myBuildTree(preorder_left + 1, preorder_left + size_left_subtree, inorder_left, inorder_root - 1)
            root.right = myBuildTree(preorder_left + size_left_subtree + 1, preorder_right, inorder_root + 1, inorder_right)
            return root
        n = len(preorder)
        index = {element: i for i, element in enumerate(inorder)}
        return myBuildTree(0, n - 1, 0 ,n - 1)

2：迭代

#递归
#超99%
# 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

        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

二、从中序与后序遍历序列构造二叉树(leetcode106)
问题：

题目来源：力扣（LeetCode）

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

难度：中等

分析：
思路与从前序和中序遍历序列构造二叉树相同，只是后序序列中的根节点值是从后面开始取的。

解决方法：
1：递归

class Solution:
    def buildTree(self, inorder: List[int], postorder: List[int]) -> TreeNode:
        def helper(in_left,in_right):
            if in_left > in_right:
                return 
            val = postorder.pop()
            root = TreeNode(val)
            index = idx_map[val]
            root.right = helper(index + 1, in_right)
            root.left = helper(in_left, index - 1)
            return root
        idx_map = {val: idx for idx, val in enumerate(inorder)}
        return helper(0,len(inorder) - 1)

三、根据前序和后序遍历构造二叉树(leetcode889)
问题：

题目来源：力扣（LeetCode）

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

难度：中等

分析：
前序遍历的根节点后的第一个值是左子树的根节点，后序遍历序列中左子树最后一个值是根节点，在后序遍历中找到左子树根节点的位置，就确定的左子树的大小，因此得以确定右子树的大小。

解决方法：
1：递归

class Solution(object):
    def constructFromPrePost(self, pre, post):
        if not pre: return None
        root = TreeNode(pre[0])
        if len(pre) == 1: return root

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