Leetcode练习：从中序与后序遍历序列构造二叉树，递归与迭代，python实现。

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

# digui
class Solution(object):
    def buildTree(self, preorder, inorder):
        """
        :type preorder: List[int]
        :type inorder: List[int]
        :rtype: TreeNode
        """
        if not len(preorder):
            return None
        return_node = TreeNode(preorder[0])
        split_index = inorder.index(preorder[0])
        return_node.left = self.buildTree(preorder[1: 1 + split_index], inorder[:split_index])
        return_node.right = self.buildTree(preorder[1 + split_index:], inorder[split_index + 1:])
        return return_node
    
# diedai
class Solution(object):
    def buildTree(self, preorder, inorder):
        """
        :type preorder: List[int]
        :type inorder: List[int]
        :rtype: TreeNode
        """
        if not len(preorder):
            return None
        
        return_node = TreeNode(preorder[0])
        
        current_level = [return_node]
        current_preorder = [preorder]
        current_inorder = [inorder]
        while(len(current_level)):
            new_level = []
            new_preorder = []
            new_inorder = []
            for i, current_node in enumerate(current_level):
                preorder = current_preorder[i]
                inorder = current_inorder[i]
                
                root_value = current_node.val
                split_index = inorder.index(root_value)
                
                left_preorder = preorder[1:split_index + 1]
                right_preorder = preorder[split_index + 1:]
                
                left_inorder = inorder[:split_index]
                right_inorder = inorder[split_index + 1:]
                
                if len(left_preorder):
                    current_node.left = TreeNode(left_preorder[0])
                    
                    new_level.append(current_node.left)
                    
                    new_preorder.append(left_preorder)
                    new_inorder.append(left_inorder)
                
                if len(right_preorder):
                    current_node.right = TreeNode(right_preorder[0])
                    
                    new_level.append(current_node.right)
                    
                    new_preorder.append(right_preorder)
                    new_inorder.append(right_inorder)
            
            current_level = new_level
            current_preorder = new_preorder
            current_inorder = new_inorder
        
        return return_node