先序与中序||后序与中序||先序与后序，求二叉树

模板通用，递归思路

树的结构：

struct node{
 	int v;
    node* l;
    node* r;
    node(int u):v(u){}//构造函数
}//树的结构
int post[N],pre[N],in[N];//遍历的节点顺序

遍历顺序的性质

先序遍历：根左右，第一个节点为根节点，根节点后一个节点为左子树根节点

后序遍历：左右根，最后一个节点为根节点，根节点前一个节点为右子树根节点

中序遍历：左根右，根节点的左边为左子树节点，右边为右子树节点

先序(preorder)与中序(inorder)

先序遍历是根左右，递归处理时从前往后推即可，递归构造树时先构造左子树，再构造右子树

int pos=0;
node* create(int l,int r){//l,r为中序遍历的该子树边界
	if(l>r)return new node(-1);
    node* nod=new(pre[pos++]);//遍历根（从前往后推）
    int mid;//找到根节点在中序遍历中的位置，以此划分左右子树
    for(mid=l;mid<=r;mid++){
        if(nod->v==in[mid])
            break;
    }
    nod->l=create(l,mid-1);//先创建左子树
    nod->r=create(mid+1,r);//后创建右子树
    return nod;
}

后序(postorder)与中序(inorder) 

后序为左右根，故从后往前推，递归构造树时先构造右子树，再构造左子树

int pos=n-1;
node* create(int l,int r){//l,r为中序遍历的边界
	if(l>r)return new node(-1);
    node* nod=new node(post[pos--]);//遍历根（后序遍历的最后一个节点往前推）
    int mid;//找到根节点在中序遍历中的位置，以此划分左右子树
    for(mid=l;mid<=r;mid++){
        if(nod->v==in[mid])
            break;
    }
    nod->r=create(mid+1,r);//先创建右子树
    nod->l=create(l,mid-1);//后创建左子树
    return nod;
}

先序(preorder)与后序(postorder) 

当前树的根在先序遍历中为第一个节点，即为pre[l1]，在后序遍历中为最后一个节点，即为post[r2]
左子树根为先序遍历的根的后一个节点，即为pre[l1+1]
右子树根为后序遍历的根的前一个节点，即为post[r2-1]

node* create(int l1,int r1,int l2,int r2){//当前遍历的树的边界
    if(l1>r1||l2>r2)return new node(-1);
    node* nod=new node(pre[l1]);//先序遍历的第一个节点即为根节点
    
    //当前树的根在先序遍历中为第一个节点，即为pre[l1]，在后序遍历中为最后一个节点，即为post[r2]
    //左子树根为先序遍历的根的后一个节点，即为pre[l1+1]
    //右子树根为后序遍历的根的前一个节点，即为post[r2-1]
    
    int left1,right1,left1,right2;
    //左子树的边界
    //先序遍历
    //左边界：l1+1
    left1=l1+1;
    //右边界：右子树根的前一个节点即为右边界
    for(right1=l1;right1<=r1;right1++){
        if(pre[right1+1]==post[r2-1])break;
    }
    //后序遍历
    //左边界：l2（后序遍历为左右根，第一个肯定是左子树的节点）
    left2=l2;
    //右边界：左子树根
    for(right2=l2;right2<=r2;right2++){
        if(post[right2]==pre[l1+1])break;
    }
    nod->l=create(left1,right1,left2,right2);//构建左子树
    
    //右子树边界
    //先序遍历
    //左边界：右子树根
    for(left1=l1;left1<=r1;left1++){
        if(pre[left1]==post[r2-1])break;
    }
    //右边界：r1
    right1=r1;
    
    //后序遍历
    //左边界:左根的后一个节点
    for(left2=l2;left2<=r2;left2++){
        if(post[left2-1]==pre[l1-1])break;
    }
    //右边界：r2-1;
    right2=r2-1;
    nod->r=create(left1,right1,left2,right2);//构建右子树
    return nod;
}