剑指 Offer 07. 重建二叉树

剑指 Offer 07. 重建二叉树

1、 问题描述

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

例如，给出

前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]

返回如下的二叉树：

3
/ \
9 20
/ \
15 7
限制：
0 <= 节点个数 <= 5000

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

2、 实例分析

前序遍历性质： 节点按照 [ 根节点 | 左子树 | 右子树 ] 排序。
中序遍历性质： 节点按照 [ 左子树 | 根节点 | 右子树 ] 排序。
中序遍历性质： 节点按照 [ 左子树 | 右子树 | 根节点 ] 排序。

以题目示例为例：
前序遍历划分 [ 3 | 9 | 20 15 7 ]
中序遍历划分 [ 9 | 3 | 15 20 7 ]

根据以上性质，可得出以下推论：

用于已知二叉树的前序遍历和中序遍历的结果，重建该二叉树
1、前序遍历的首元素 为 树的根节点 node 的值。
2、在中序遍历中搜索根节点 node 的索引 ，可将 中序遍历 划分为[左子树 | 根节点 | 右子树 ] 。
3、根据中序遍历中的左 / 右子树的节点数量，可将 前序遍历 划分为 [ 根节点 |左子树前序 |右子树前序 ] 。
通过以上三步，可确定 三个节点 ：
1.树的根节点、左子树前序和中序、右子树前序和中序
对于树的左、右子树的前序和中序，仍可使用以上步骤划分子树的左右子树的前序和中序。

用于已知二叉树的后序遍历和中序遍历的结果，重建该二叉树
4、后序遍历的尾元素 为 树的根节点 node 的值。
5、在中序遍历中搜索根节点 node 的索引 ，可将 中序遍历 划分为[左子树 | 根节点 | 右子树 ] 。
6、根据中序遍历中的左 / 右子树的节点数量，可将 后序遍历 划分为 [ 根节点 |左子树后序 |右子树后序 ]

3、 分析总结

使用递归 依次传入参数 各个子树的前序和中序

pytthon实现

class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

class Solution:
    def buildTree(self, preorder, inorder):
        '''
        前序列表和中序列表求二叉树
        :param preorder: : list[int]
        :param inorder: : list[int]
        :return: -> TreeNode
        '''
        if not preorder:
            return None
        root = TreeNode(preorder[0])  # 先序列表第一个元素即为树的根
        # 找到根节点在中序遍历中的下标，以根在中序列表中的位置将先序和中序列表各分成两个部分（不包括根节点）
        # 左半部分是左子树的先序和中序，右半部分是右子树的先序和中序
        n = inorder.index(root.val)
        root.left = self.buildTree(preorder[1:n + 1], inorder[:n])  # 左半边的先序和中序
        root.right = self.buildTree(preorder[n + 1:], inorder[n + 1:])  # 右半边的先序和中序
        return root
# —————————————————————————————下面为扩展———————————————————————————————————————
    def buildTree2(self, Postorder, inorder):
        '''
        后序列表和中序列表求二叉树
        '''
        if not Postorder:
            return None
        root = TreeNode(Postorder[-1])  # 先序列表第一个元素即为树的根
        # 找到根节点在中序遍历中的下标，
        # 以根在中序列表中的位置将后序和中序列表各分成两个部分（不包括根节点）
        # 左半部分是左子树的后序和中序，右半部分是右子树的后序和中序
        n = inorder.index(root.val)
        root.left = self.buildTree2(Postorder[0:n], inorder[:n])  # 左半边的先序和中序
        root.right = self.buildTree2(Postorder[n:-1], inorder[n+1:])  # 右半边的先序和中序
        return root
    def PreorderTraversingBinaryTree(self,Tree_Root:TreeNode):
        '''
        先序遍历二叉树
        '''
        if Tree_Root !=None:
            print(Tree_Root.val)
            self.PreorderTraversingBinaryTree(Tree_Root.left)
            self.PreorderTraversingBinaryTree(Tree_Root.right)
    def InorderTraversingBinaryTree(self,Tree_Root:TreeNode):
        '''
        中序遍历二叉树
        '''
        if Tree_Root !=None:

            self.InorderTraversingBinaryTree(Tree_Root.left)
            print(Tree_Root.val)
            self.InorderTraversingBinaryTree(Tree_Root.right)
    def PostorderTraversingBinaryTree(self,Tree_Root:TreeNode):
        '''
        后序遍历二叉树
        '''
        if Tree_Root !=None:
            self.PostorderTraversingBinaryTree(Tree_Root.left)
            self.PostorderTraversingBinaryTree(Tree_Root.right)
            print(Tree_Root.val)


# 前序遍历性质： 节点按照 [ 根节点 | 左子树 | 右子树 ] 排序。
# 中序遍历性质： 节点按照 [ 左子树 | 根节点 | 右子树 ] 排序。
# 中序遍历性质： 节点按照 [ 左子树 | 右子树 | 根节点 ] 排序。
preorder = [3,9,20,15,7]  # 前序遍历
inorder = [9,3,15,20,7]  # 中序遍历
Postorder = [9,15,7,20,3]
print(Postorder[0:1])
S = Solution()
root = S.buildTree(preorder,inorder)
# root = S.buildTree2(Postorder,inorder) 
S.PreorderTraversingBinaryTree(root)
S.InorderTraversingBinaryTree(root)
S.PostorderTraversingBinaryTree(root)