老会忘的二叉树遍历建树输出

#include<iostream>  
using namespace std;  
int pre[] = {1, 2, 3, 4, 5, 6};  
int mid[] = {3, 2, 4, 1, 6, 5};  
void post(int root, int start, int end) 
{  
    if(start > end)   
        return ;  
    int i = start;  
    while(i < end && mid[i] != pre[root]) i++;  //定位根在中序的位置
    post(root + 1, start, i - 1);  //递归处理左子树
    post(root + 1 + i - start, i + 1, end);  //递归处理右子树
    //cout<<pre[root];  //访问当前树的根
    cout<<mid[i];
}  

int main() 
{  
    post(0, 0, 5);  
    return 0;  
} 

#include<iostream>  
using namespace std;  
int post[] = {3, 4, 2, 6, 5, 1};  
int mid[] = {3, 2, 4, 1, 6, 5};  
void pre(int root, int start, int end) 
{  
    if(start > end)   
        return ;  
    int i = start;  
    while(i < end && mid[i] != post[root]) i++;  //定位根在中序的位置
    cout<<mid[i];  //访问当前处理的树的根
    pre(root-1-(end-i), start, i - 1);  //递归处理左子树
    pre(root-1, i + 1, end);  //递归处理右子树  
}  

int main()
 {  
    pre(5, 0, 5);  
    return 0;  
}

treenode reconstructbinarytree(int[] pre, int prestart, int preend, int[] in, int instart, int inend) {
    if (prestart > preend || instart > inend) { //到达边界条件时返回null
        return null;
    }
    treenode treenode = new treenode(pre[prestart]);   //新建一个treenode

    for (int i = instart; i <= inend; i++) {
        if (in[i] == pre[prestart]) {    //在中序中找到根节点的位置，【依次】将先序序列和中序序列分成左右字树，分别构建左右子树。
            // 重构左子树，注意边界条件
            treenode.left = reconstructbinarytree(pre, prestart + 1, prestart + i - instart, in, instart, i - 1);
            // 重构右子树，注意边界条件
            treenode.right = reconstructbinarytree(pre, prestart + i - instart + 1, preend, in, i + 1, inend);
        }
    }
    return treenode;
}

treenode reconstructbinarytree2(int[] in, int instart, int inend, int[] last, int laststart, int lastend) {
    if (instart > inend || laststart > lastend)
        return null;
    treenode treenode = new treenode(last[lastend]);
    for (int i = instart; i <= inend; i++) {
        if (in[i] == last[lastend]) {
            treenode.left = reconstructbinarytree2(in, instart, i - 1, last, laststart, laststart + i - instart - 1);
            treenode.right = reconstructbinarytree2(in, i + 1, inend, last, laststart + i - instart, lastend - 1);
        }
    }
    return treenode;
}

vector<int> v;
void getpost(int root, int last) {
    int i = root + 1, j = last;
    while (a[i] < a[root] && i <= last)i++;//找当前根节点左子节点边界
    while (a[j] >= a[root] && j > root)j--;//找当前根节点右子节点边界
    if (i - j != 1)return;
    getpost(root + 1, j);//遍历左子节点
    getpost(i, last);//遍历右子节点
    v.push_back(a[root]);//pb根节点(左右根)
}

int post[1005], in[1005];
map<int, int> ma, le;
void level(int root, int l, int r, int index) {
    if (l > r)return;
    int p = ma[post[root]];//当前后序所在根节点前序位置
    le[index] = post[root];//index为节点下标
    level(root - r + p - 1, l, p - 1, 2 * index);//root - (r - p) - 1是当前后序根节点位置减去(其右子树节点个数)再减一位
    level(root - 1, p + 1, r, 2 * index + 1);
}

int main() {
    int n;
    cin >> n;
    for (int i = 1; i <= n; i++) {
        cin >> post[i];
    }
    for (int i = 1; i <= n; i++) {
        cin >> in[i];
        ma[in[i]] = i;
    }
    level(n, 1, n, 1);
}