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

根据一棵树的前序遍历与中序遍历构造二叉树。

注意:

你可以假设树中没有重复的元素。

例如，给出

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

返回如下的二叉树：

					    3
					   / \
					  9  20
					    /  \
					   15   7

solution

Python

作者：LeetCode
链接：https://leetcode-cn.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/solution/cong-qian-xu-he-zhong-xu-bian-li-xu-lie-gou-zao-er/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

# 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, inorder):
        """
        :type preorder: List[int]
        :type inorder: List[int]
        :rtype: TreeNode
        """
        def helper(in_left = 0, in_right = len(inorder)):
            nonlocal pre_idx
            # if there is no elements to construct subtrees
            if in_left == in_right:
                return None
            
            # pick up pre_idx element as a root
            root_val = preorder[pre_idx]
            root = TreeNode(root_val)

            # root splits inorder list
            # into left and right subtrees
            index = idx_map[root_val]

            # recursion 
            pre_idx += 1
            # build left subtree
            root.left = helper(in_left, index)
            # build right subtree
            root.right = helper(index + 1, in_right)
            return root
        
        # start from first preorder element
        pre_idx = 0
        # build a hashmap value -> its index
        idx_map = {val:idx for idx, val in enumerate(inorder)} 
        return helper()

my

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    void my_buildTree(vector<int>& preorder, int pst, int ped, vector<int>& inorder, int ist, int ied, TreeNode *&head){
        int key = preorder[pst];
        TreeNode *node = new TreeNode(key);
        head = node;
        auto idx = find(inorder.begin(), inorder.end(), key) - inorder.begin();
        int leftSz = idx - ist, rightSz = ied - (idx + 1);
        ++pst;
        if(leftSz)
            my_buildTree(preorder, pst, pst + leftSz, inorder, ist, idx, head->left);
        if(rightSz)
            my_buildTree(preorder, pst + leftSz, ped, inorder, idx + 1, ied, head->right);
    }
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        int sz = preorder.size();
        TreeNode *head = NULL;
        if(sz)
            my_buildTree(preorder, 0, sz, inorder, 0, sz, head);
        return(head);
    }
};