二叉树建树的若干问题

问题1二叉树有一种问题很经典，如果给出中序遍历和前序遍历的序列，如何建立一个颗二叉树数？（实际上后续遍历和前序遍历是一样的，可以替换掉前序遍历的）

那么我们容易知道，前序遍历序列的第一个节点就是root，那么我们在中序遍历找出这个点，那么在这个点的左边就是左子树的中序遍历序列，右边亦然，那么前序遍历在除掉第一个点以后与左子树的中序遍历序列相同数量相对应，构成一个规模缩小，但是问题一致的子问题，所以很显然，这个是可以递归解决的，递归的关键是就是中序遍历序列和前序遍历序列要有一个对应。
这个很容易就可以想明白。
代码

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<queue>
#include<algorithm>
#include<set>
#include<map>
using namespace std;

struct node
{
    int data;
    node* l;
    node* r;
};
int pre[1000];
int in[1000];
node *root;
node* findd(int l,int r,int L,int R)//l到r是中序序列，L到R是前序序列
{
    if(l>r)
        return NULL;//递归边界，显然
    int p;
    for(p=l;p<r;p++)
        if(in[p]==pre[L])//寻找双亲节点
            break;
    node* now=new node;
    now->l=findd(l,p-1,L+1,L+(p-l));
    now->r=findd(p+1,r,L+(p-l)+1,R);
    now->data=in[p];
    return now;
}
int main()
{

    int n;//节点个数
    scanf("%d",&n);
    for(int i=0;i<n;i++)
        scanf("%d",pre+i);
    for(int i=0;i<n;i++)
        scanf("%d",in+i);
    root=findd(0,n-1,0,n-1);
    return 0;
}

问题2如何通过中序遍历和层序遍历重建二叉树？
这个问题如果人工操作的话也应该是可以想明白的，那代码怎么写？
就是我们是怎么知道一个点是否有左右的字节点？假设从层序遍历开始，那么易知第一个便是根节点（root），那么我在中序中去找这个节点，如果这个点左右两边都有点，那么我们就可以知道root左右两边都有孩子，
所以我们应该不断的去寻找根节点，然后判断是否有左右孩子，在哪里寻找孩子？需要我们提供区间，那么根节点的寻找就应当根据广搜的这种形式，所以这个问题应该用bfs解决。
代码

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<queue>
#include<algorithm>
#include<set>
#include<map>
#define INF 0x3f3f3f3f
#define mod 1000000007
using namespace std;

struct node
{
    int data;
    node* l;
    node* r;
};
int layer[1000];
int in[1000];
node *root;
struct node2
{
    int l,r;
    node* now;
};//队列中存放的单位
int main()
{
    int n;//节点个数
    scanf("%d",&n);
    for(int i=0;i<n;i++)
        scanf("%d",layer+i);
    for(int i=0;i<n;i++)
        scanf("%d",in+i);
    queue<node2> que;
    root=new node;
    root->data=layer[0];
    root->l=root->r=NULL;
    node2 p;
    p.l=0;
    p.r=n-1;
    p.now=root;
    que.push(p);
    int countt=1;
    while(!que.empty())
    {
        node2 temp=que.front();
        que.pop();
        int mid;
        for(mid=temp.l;mid<=temp.r;mid++)
            if(in[mid]==temp.now->data)
                break;
        if(temp.l<mid)//说明这个节点有左儿子
        {
            node *left=new node;
            left->data=layer[countt++];
            left->l=left->r=NULL;
            node2 temp1;
            temp1.l=temp.l;
            temp1.r=mid-1;
            temp1.now=left;
            que.push(temp1);
        }
        if(mid<temp.r)//说明这个节点有右儿子
        {
            node *right=new node;
            right->data=layer[countt++];
            right->l=right->r=NULL;
            node2 temp1;
            temp1.l=mid+1;
            temp1.r=temp.r;
            temp1.now=right;
            que.push(temp1);
        }
    }
    return 0;
}

思考：易知无论是前序后续还是层序，本质上就是提供根节点（相对而言）无论如何我们至少是需要中序遍历，以此来得到左右子树。
以上问题没有具体的题目，所写的代码均为个人理解，如果有更加优化的写法，欢迎指出。
如果还有遇到有趣的相关问题，下次再更新|·ω･｀)