LeetCode build tree questions

二叉树的建树和序列化问题有很多，
中序加后序建树
https://leetcode.com/problems/construct-binary-tree-from-inorder-and-postorder-traversal/
前序建搜索树
https://leetcode.com/problems/construct-binary-search-tree-from-preorder-traversal/
前序加后序建树
https://leetcode.com/problems/construct-binary-tree-from-preorder-and-postorder-traversal/
前序加中序建树
https://leetcode.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/

基本的思路其实还是用递归法来解决这些问题，中序加后序的，我们从后向前看，把中序和后序每次分成两部分，继续使用递归去解决找到子树。

    def buildTree(self, inorder: List[int], postorder: List[int]) -> TreeNode:
        if not inorder:
            return None
        
        posDict = collections.defaultdict(int)
        for i, val in enumerate(inorder):
            posDict[val] = i

        return Solution.buildTreeHelp(inorder, 0, len(inorder) -1, postorder, posDict)
        
    @staticmethod
    def buildTreeHelp(inorder: List[int], si: int, ei: int, postorder: List[int], posDict: dict) -> TreeNode:
        if si > ei:
            return None

        root = TreeNode(postorder[-1])
        root.val = postorder[-1]
        ipos = posDict[root.val]
        root.left = Solution.buildTreeHelp(inorder, si, posDict[root.val] -1, postorder[0: ipos-si], posDict)
        root.right = Solution.buildTreeHelp(inorder, ipos +1, ei, postorder[ipos-si: -1], posDict)

        return root    

前序建搜索树，可以通过不断的插入新节点来重建

    def bstFromPreorder(self, preorder: List[int]) -> TreeNode:
        if preorder == None or len(preorder) == 0: return None

        root = TreeNode(preorder[0])

        def insertNode(node, val):
            if val < node.val:
                if node.left == None:
                    node.left = TreeNode(val)
                else:
                    insertNode(node.left, val)
            else:
                if node.right == None:
                    node.right = TreeNode(val)
                else:
                    insertNode(node.right, val)        
        
        for i in range(1, len(preorder)):
            insertNode(root, preorder[i])
        return root              

前序加后序，这个稍微麻烦一点，但是根本的原理还是，利用递归，不断的把两个序列拆成两部分来建立左右子树。

    def constructFromPrePost(self, pre: List[int], post: List[int]) -> TreeNode:
        if len(pre) == 0 or len(post) == 0: return None

        if pre[0] == post[-1]:
            currentNode = TreeNode(pre.pop(0))
            post.pop()

        if len(pre) == 0 or len(post) == 0:
            return currentNode

        try:
            index = post.index(pre[0])
        except ValueError:
            return currentNode

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

        return currentNode

前序加中序建树，其实和后续加中序是非常类似的，稍微换个写法，代码更加简单：

    def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
        if len(preorder) == 0 or len(inorder) == 0: 
            return None

        currentNode = TreeNode(preorder.pop(0))
        index = inorder.index(currentNode.val)

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