先序 中序 后序转换

已知先序，后序 求中序

class Solution {
public:
    /**
     * 返回所求中序序列
     * @param n int整型 二叉树节点数量
     * @param pre int整型vector 前序序列
     * @param suf int整型vector 后序序列
     * @return int整型vector
     */
    vector<int> vc;
    int pr[100005],ho[100005];
    void dfs(int l,int r,int ll,int rr){
        int i,len;
        for(i=ll;i<rr;i++){
            if(ho[i]==pr[l+1]){
                len = i-ll;
                dfs(l+1,l+len+1,ll,i);
                break;
            }
        }
        vc.push_back(pr[l]);
        if(l+len+2>r) return ;
        dfs(l+len+2,r,i+1,rr-1);
    }
    vector<int> solve(int n, vector<int>& pre, vector<int>& suf) {
        vc.clear();
        for(int i=0;i<n;i++){
            pr[i]=pre[i];
            ho[i]=suf[i];
        }
        dfs(0,n-1,0,n-1);
        return vc;
    }
};

 

已知先序，中序 求后序

 

class Solution {
public:
    /**
     * 返回所求后序序列
     * @param n int整型 二叉树节点数量
     * @param pre int整型vector 前序序列
     * @param suf int整型vector 中序序列
     * @return int整型vector
     */
    vector<int> vc;
    int pr[100005],ho[100005];
    void dfs(int l,int r,int L,int R){
        int i,len;
        for(i=L+1;i<=R;i++){
            if(ho[i]==pr[l]){
                len = i-L;
                dfs(l+1,l+len,L,i-1);
                break;
            }
        }
        if(l+len+1<=r) dfs(l+len+1,r,i+1,R);
        vc.push_back(pr[l]);
    }
    vector<int> solve(int n, vector<int>& pre, vector<int>& suf) {
        vc.clear();
        for(int i=0;i<n;i++){
            pr[i]=pre[i];
            ho[i]=suf[i];
        }
        dfs(0,n-1,0,n-1);
        return vc;
    }
};

 

已知后序 中序 求先序

class Solution {
public:
    /**
     * 返回所求后序序列
     * @param n int整型 二叉树节点数量
     * @param pre int整型vector 后序序列
     * @param suf int整型vector 中序序列
     * @return int整型vector
     */
    vector<int> vc;
    int pr[100005],ho[100005];
    void dfs(int l,int r,int L,int R){
        int i,len;
        vc.push_back(pr[r]); 
        for(i=L+1;i<=R;i++){
            if(ho[i]==pr[r]){ 
                len = i-L;
                dfs(l,l+len-1,L,i-1);
                break;
            }
        }
        if(l+len+1<=r) dfs(l+len,r-1,i+1,R);
    }
    vector<int> solve(int n, vector<int>& pre, vector<int>& suf) {
        vc.clear();
        for(int i=0;i<n;i++){
            pr[i]=pre[i];
            ho[i]=suf[i];
        }
        dfs(0,n-1,0,n-1);
        return vc;
    }
};