重建二叉树---(先序+中序) and (中序+后序)

1：先序加中序

输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

1.1 思路

• 用数学归纳法的思想就是，假设最后一步，就是root的左右子树都已经重建好了，那么我只要考虑将root的左右子树安上去即可
• 根据前序遍历的性质，第一个元素必然就是root，那么下面的工作就是如何确定root的左右子树的范围。
• 根据中序遍历的性质，root元素前面都是root的左子树，后面都是root的右子树。那么我们只要找到中序遍历中root的位置，就可以确定好左右子树的范围。
• 正如上面所说，只需要将确定的左右子树安到root上即可。递归要注意出口，假设最后没有元素，那么就返回None。

1.2 python实现

class Solution:
    # 返回构造的TreeNode根节点
    def reConstructBinaryTree(self, pre, tin): # 自顶向下分解，自底向上构建二叉树
        # write code here
        if not pre or not tin: return None  # 划分左右子树时有一个为空
        
        root = TreeNode(pre.pop(0)) # 取出并删除第一个元素，也就是根节点
        index = tin.index(root.val)  # 找到中序遍历中根节点的位置，划分左右
        root.left = self.reConstructBinaryTree(pre, tin[:index]) # 重建左子树
        root.right = self.reConstructBinaryTree(pre, tin[index+1:]) # 重建右子树
        return root

优化方法： 不用切片，而是用访问下标来做比较好,并且也用map存储中序中各个数字的位置

class Solution(object):
    def buildTree(self, preorder, inorder):      
        def build(preorder, pi, pj, inorder, ii, ij, mapp):
            if pi > pj or ii > ij: return None
            root = TreeNode(preorder[pi])
            index = mapp[root.val]
            root.left = build(preorder, pi+1, pi+index-ii, inorder, ii, index-1, mapp) # pi + (index-ii) 左子树的列表长度
            root.right = build(preorder, pi+index-ii+1, pj, inorder, index+1, ij, mapp) # pi + (index-(ii-1)) 右子树的列表长度
            return root
        
        if not preorder or not inorder or len(preorder) != len(inorder): return None
        mapp = dict() # 每个结点值是唯一的
        for i in range(len(inorder)):
            mapp[inorder[i]] = i
        root = build(preorder, 0, len(preorder)-1, inorder, 0, len(inorder)-1, mapp)
        return root

2. 中序加后序

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

2.1 思路

后序遍历的最后一个节点是根节点，所以和先序加中序的思想是一样的，只是这里是把后序遍历的最后一个节点作为根节点，然后划分左右子树。

2.2 python实现

class Solution:
    # 返回构造的TreeNode根节点
    def reConstructBinaryTree2(self, tin, post): # 自顶向下分解，自底向上构建二叉树
        # write code here
        if not tin or not post: return None  # 划分左右子树时有一个为空
        
        root = TreeNode(post.pop()) # 取出并删除最后一个元素，也就是根节点
        index = tin.index(root.val)  # 找到中序遍历中根节点的位置，划分左右
        
        # 需要先构建右子树，再构建左子树，index()函数才不会保错
        root.right = self.reConstructBinaryTree(tin[index+1:], post) # 重建右子树
        root.left = self.reConstructBinaryTree(tin[:index], post) # 重建左子树
        return root

优化方法： 不用切片，而是用访问下标来做比较好,并且也用map存储中序中各个数字的位置

class Solution(object):
    def buildTree(self, inorder, postorder):
        
        def build(inorder, ii, ij, postorder, pi, pj, mapp):
            if ii > ij or pi > pj: return None
            root = TreeNode(postorder[pj])
            index = mapp[root.val]
            root.left = build(inorder, ii, index-1, postorder, pi, pi+index-ii-1, mapp)
            root.right = build(inorder, index+1, ij, postorder, pi+index-ii, pj-1, mapp)
            return root
        
        if not inorder or not postorder or len(inorder) != len(postorder): return None
        mapp = dict() # 每个结点值是唯一的
        for i in range(len(inorder)):
            mapp[inorder[i]] = i
        root = build(inorder, 0, len(inorder)-1, postorder, 0, len(postorder)-1, mapp)
        return root

3. 先序 + 后序

一棵二叉树除叶子节点外，其他所有的节点都有左孩子和右孩子，才能被先序和后序数组重构出来。（唯一与不唯一的区别）