给定任意两种遍历结果，重建树的结构(Leetcode105、106、889)

1. 前序是中左右，中序是左中右，后序是左右中。
2. 问题的关键在于计算左子树元素个数。
3. 用中序计算左子树元素个数（InRootInd-inL）。而对于前序和后序的情况，用后序计算左子树元素个数（postLind-postL+1）。
4. 对于中序，需要确定中序中根的位置（InRootInd），根的位置通过前序中第一个元素，或后序中最后一个元素（rootval）确定。而对于前序和后序的情况，需要确定后序中左子树的最后一个元素(左子树的根)位置（postLind），这是通过先序中第二个元素(preL+1，也是左子树的根)确定(lval)。
5. 通过unordered_map优化检索时间。

class Solution {
public:
    TreeNode* buildTree(vector& preorder, vector& inorder) {
        int n=preorder.size();
        unordered_map hm;
        for(int i=0;i
            hm[inorder[i]]=i;
        }
        return build(preorder,0,n-1,0,n-1,hm);
    }

    TreeNode* build(vector& preorder,int preL,int preR,int inL,int inR,unordered_map& hm){
        if(preL>preR||inL>inR){
            return nullptr;
        }
        int rootVal=preorder[preL];
        TreeNode* root=new TreeNode(rootVal);
        int InRootInd=hm[rootVal];
        int leftSize=InRootInd-inL;
        root->left=build(preorder,preL+1,preL+leftSize,inL,InRootInd-1,hm);
        root->right=build(preorder,preL+leftSize+1,preR,InRootInd+1,inR,hm);
        return root;
    }

class Solution {
public:
    TreeNode* buildTree(vector& inorder, vector& postorder) {
        int n=inorder.size();
        unordered_map hm;
        for(int i=0;i
            hm[inorder[i]]=i;
        }
        return build(inorder,0,n-1,postorder,0,n-1,hm);
    }

    TreeNode* build(vector& inorder,int inL,int inR,vector& postorder,int postL,int postR,unordered_map &hm){
        if(inL>inR||postL>postR){
            return nullptr;
        }
        TreeNode *root=new TreeNode(postorder[postR]);
        if(inL==inR){
            return root;
        }
        int inRootInd=hm[postorder[postR]];
        int leftSize=inRootInd-inL;
        root->left=build(inorder,inL,inL+leftSize-1,postorder,postL,postL+leftSize-1,hm);
        root->right=build(inorder,inRootInd+1,inR,postorder,postL+leftSize,postR-1,hm);

        return root;
    }
};

class Solution {
public:
    TreeNode* constructFromPrePost(vector& preorder, vector& postorder) {
        int n=preorder.size();
        if(n==0){
            return nullptr;
        }
        unordered_map posthm;
        for(int i=0;i
            posthm[postorder[i]]=i;
        }
        return dfs(preorder,0,n-1,postorder,0,n-1,posthm);
    }
    TreeNode* dfs(vector& preorder,int preL,int preR,vector& postorder,int postL,int postR,unordered_map& posthm){
        if(preL>preR||postL>preR){
            return nullptr;
        }
        TreeNode* root=new TreeNode(preorder[preL]);
        if(preL==preR){
            return root;
        }

        int lval=preorder[preL+1];
        int postLind=posthm[lval];
        // 左子树的元素个数
        int leftSize=postLind-postL+1;
        cout<<"lval="<left=dfs(preorder,preL+1,preL+leftSize,postorder,postL,postLind,posthm);
        root->right=dfs(preorder,preL+leftSize+1,preR,postorder,postLind+1,postR-1,posthm);
        
        return root;
    }
};