剑指offer：由前序和中序序列重建二叉树

原题链接：https://www.acwing.com/problem/content/description/23/

每个节点的值都互不相同，所以我们可以使用哈希表。 我们在初始化时，用哈希表(unordered_map<int,int>)记录每个值在中序遍历中的位置，这样我们在递归到每个节点时，在中序遍历中查找根节点位置的操作，只需要 O(1)O(1) 的时间。此时，创建每个节点需要的时间是 O(1)O(1)，所以总时间复杂度是 O(n)O(n)。

参考题解：https://www.acwing.com/solution/content/2244/

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
 
 /*
 用dfs算法构建子树。
1. 首先， 把整个前序(pre)数组已经(in)中序数组的索引传入dfs程序。
2. 接着， 找到pre数组的第一个数，这就是剩下所有的子树的根，如果其为空，则返回为0.
3. 如果不为空，那么找到其在中序数组中所在的位置，记为k。
4. 接着遍历地生成左子树以及右子树。
5. 假设本次的pre数组的范围是[pl,pr]，而in数组的范围是[il,ir]。
6. 那么，左子树的pre数组范围是[pl+1,pl+k-il]，因为在左子树的起始点肯定从pl+1开始，
而由于是pre前序遍历，前面遍历的肯定都是左子树的，然而现在这个树可能是上一层的右子树，
也就是有il个点遍历过了，所以还要遍历k-il个点。
7. 左子树的in数组范围是[il,k-1]，刚好在k号点之前的元素，这个很简单不需要解释。
8. 右子树的pre数组的范围是[pl+k-il+1,pr]，也就是刚好是剩下的那些点。
9. 右子树的in数组的范围是[k+1,ir]，也就是剩下的点。

把边界搞清楚了，编程就很容易了。下面是java代码

时间复杂度分析：blablabla

作者：轻叶
链接：https://www.acwing.com/solution/content/2244/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
 */
class Solution {
public:
    
    // 用哈希表(unordered_map<int,int>)记录每个值
    // 在中序遍历中的位置，这样我们在递归到每个节点时，
    // 在中序遍历中查找根节点位置的操作，只需要 O(1)的时间。
    unordered_map<int, int> pos;
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        int n = preorder.size();
        for(int i = 0; i < n; i ++)
            pos[inorder[i]] = i;
        return dfs(preorder, inorder, 0, n-1, 0, n-1);
    }
    
    // pl,pr是这颗树在前序遍历序列中的位置。il和ir是这棵树在中序遍历序列中的位置
    TreeNode* dfs(vector<int>& pre, vector<int>& in, int pl, int pr, int il, int ir)
    {
        if(pl > pr) return NULL;
        // k是左子树节点数量， 即中序序列中原始的根节点位置 - 前面已经建立过的可能的其他树
        // 前边又il个点遍历了：从0 到 il-1
        int k = pos[pre[pl]] - il;
        TreeNode* root = new TreeNode(pre[pl]);
        root->left = dfs(pre, in, pl + 1, pl + k, il, il + k - 1);
        root->right = dfs(pre, in, pl + k + 1, pr, il + k + 1, ir);
        
        return root;
    }
};

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution(object):
    def buildTree(self, preorder, inorder):
        """
        :type preorder: List[int]
        :type inorder: List[int]
        :rtype: TreeNode
        """
        self.pos = {}
        self.preorder = preorder
        for i, val in enumerate(inorder):
            self.pos[val] = i
        return self.recur(0, 0, len(inorder) - 1)
        
    def recur(self, pre_left, in_left, in_right):
        if in_left > in_right:
            return
        
        val = self.preorder[pre_left]
        root = TreeNode(val)
        k = self.pos[val]
        left_length = k - in_left
        root.left = self.recur(pre_left + 1,
                                in_left, k - 1)
        root.right = self.recur(pre_left + 1 + left_length, k + 1, in_right)
        
        return root