森林转换成二叉树以及二叉树还原为森林代码

/*
     森林转换成二叉树
     思路：u的孩子节点为v1, v2, v3....（v1,v2,....互为兄弟节点） 
     那么将u的一个孩子节点（v1）连在u的左子树上，那么其他的孩子节点都连在v1的右子树上！ 
*/ 
#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
int g[15][15];
int par[15];//如果该节点有父亲节点说明该节点不是一个独立的点！ 
int vis[15];

struct Tree{
    int  d;
    Tree *lchild, *rchild; 
    Tree(){
       lchild=rchild=NULL; 
    }
    
    Tree(int x){
       lchild=rchild=NULL; 
       d=x;
    }
};
int n, m;

void buildT(Tree* &T, int u){
    bool flag=false;
    T=new Tree(u);
    Tree *cur=T; 
    vis[u]=1;
    for(int v=1; v<=n; ++v)
       if(g[u][v]){
          if(!flag){
             buildT(cur->lchild, v);
             cur=cur->lchild;
             flag=true;
          }
          else{
             buildT(cur->rchild, v);
             cur=cur->rchild;
          }
       }
}


void prePrint(Tree *T){
   if(!T) return ;
   cout<<T->d<<" ";
   prePrint(T->lchild);
   prePrint(T->rchild);
}


int main(){
   Tree *T=NULL; 
   while(cin>>n>>m){
         memset(g, 0, sizeof(g));
         memset(vis, 0, sizeof(vis));
      while(m--){
         int u, v;
         cin>>u>>v;
         g[u][v]=1;
         par[v]=u;
      }
      bool flag=false;
      Tree *cur;
      for(int i=1; i<=n; ++i)
          if(!vis[i]){ 
             if(!flag){
                flag=true;
                buildT(T, i); 
                cur=T; 
             }
             else if(!par[i]){//也就是找入度为0的节点！ 
                buildT(cur->rchild, i);
                cur=cur->rchild;
             }
          }
      prePrint(T);
   }
   return 0;
}
 

//数组实现....森林转成二叉树以及二叉树还原成森林
#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#define N 100 
using namespace std;

int mp[N][N];
int pp[N][N];
int n, m;
int ld[N], rd[N], par[N];

void printT(int u){
    if(u==0) return;
    printT(ld[u]);
    printT(rd[u]); 
    printf("%d ", u);
}

void rebuildMap(int u, int fa){
    if(u==0) return ;
    if(fa!=-1)  pp[fa][u]=1;
    rebuildMap(ld[u], u);
    rebuildMap(rd[u], fa);//u节点以及其兄弟节点的父亲节点都是u的父亲节点
} 

void buildT(int u){
    int v, cur;
    bool flag=false; 
    for(v=1; v<=n; ++v)
        if(mp[u][v]){
            if(!flag){
                ld[u]=v;
                cur=v;
                flag=true;
            }
            else{
                rd[cur]=v;//将u的兄弟节点都链接在右子树上
                cur=v;
            }
            buildT(v);
        } 
}

int main(){
    while(scanf("%d%d", &n, &m)!=EOF){
        memset(par, 0, sizeof(par));
        memset(pp, 0, sizeof(pp));
        memset(mp, 0, sizeof(mp));
        while(m--){
            int u, v;
            scanf("%d%d", &u, &v);
            mp[u][v]=1;
            par[v]=u;
        } 
        int root=-1, cur;
        for(int i=1; i<=n; ++i){
             if(!par[i]){
                 if(root!=-1) rd[cur]=i;
                 if(root==-1) root=i; 
                 buildT(i); 
                 cur=i;
             }
        }
        printf("打印树.....
"); 
        printT(root);
        printf("
");
        rebuildMap(root, -1);
        printf("

还原树....
"); 
        for(int i=1; i<=n; ++i)
              for(int j=1; j<=n; ++j)
                  if(pp[i][j])
                        printf("%d %d
", i, j);
        printf("KO!
"); 
    }
    return 0;
} 
/*
测试数据.....
11 8
2 1
2 3
2 4
5 6
6 9
5 7
5 8
11 10
*/