根据后序遍历和中序遍历的数组构建二叉树

TreeNode* buildTree (vector<int> &inorder, vector<int> &postorder)
{
    if (inorder.empty ()) {
        return nullptr;
    }
    
    unordered_map<int, INTVECIT> inItDic;
    unordered_map<int, INTVECIT> postItDic;
    
    for (auto it = inorder.begin(); it != inorder.end(); ++it){
        inItDic[*it] = it;
    }
    
    for (auto it = postorder.begin(); it != postorder.end(); ++it){
        postItDic[*it] = it;
    }
    
    auto rootVal      = postorder.back ();
    auto root         = new TreeNode (rootVal);
    auto rootIt = inItDic[rootVal];
    
    function<void(TreeNode*, INTVECIT, INTVECIT)> build;
    build = [&] (TreeNode *subRoot, INTVECIT begin, INTVECIT end)
    {
        if (begin == end) {
            return;
        }
        
        set<INTVECIT> weights;
        for (auto it = begin; it != end; ++it) {
            weights.insert (postItDic[*it]);
        }
        auto newSubRootVal = **weights.crbegin ();
        auto newSubRoot = new TreeNode (newSubRootVal);
        
        if (newSubRootVal < subRoot->val) {
            subRoot->left = newSubRoot;
        }
        else {
            subRoot->right = newSubRoot;
        }
        
        auto newSubRootIt = inItDic[newSubRootVal];
        build (newSubRoot, begin, newSubRootIt);
        build (newSubRoot, newSubRootIt + 1, end);
    };
    
    build (root, inorder.begin(), rootIt);
    build (root, rootIt + 1, inorder.end());
    
    return root;
}

TreeNode* buildTree (vector<int> &inorder, vector<int> &postorder)
{
    using IndexType = vector<int>::size_type;
    if (inorder.empty () || postorder.empty() || inorder.size() != postorder.size()) {
        return nullptr;
    }
    
    unordered_map<int, int> inIndexDic;
    
    for (auto i = 0; i < inorder.size(); ++i) {
        inIndexDic[inorder[i]] = i;
    }
    
    function<TreeNode*(IndexType, IndexType, IndexType, IndexType)> build;
    build = [&] (IndexType inBegin, IndexType inEnd, IndexType postBegin, IndexType postEnd) -> TreeNode*
    {
        if (inBegin == inEnd) {
            return nullptr;
        }
        
        IndexType newRootIndex = inIndexDic[postorder[postEnd - 1]];
        IndexType leftSize = newRootIndex - inBegin;
        IndexType rightSize = inEnd - newRootIndex - 1;
        
        auto newRoot = new TreeNode(inorder[newRootIndex]);
        newRoot->left = build(inBegin, newRootIndex, postBegin, postBegin + leftSize);
        newRoot->right = build(newRootIndex + 1, inEnd, postBegin + leftSize, postBegin + leftSize + rightSize);
        return newRoot;
    };
    
    return build(0, inorder.size(), 0, postorder.size());
}