以输入边中的子节点为索引来建树（因为子节点才具有唯一性，只会在输入边中提及一次）。先进行一次深度优先搜索在结构体内部记录下该节点的深度，然后进行广度优先搜索打印节点。

题目描述
老师有一个问题想考考mabo，但是mabo不会，所以想请你来帮帮忙。

问题如下：

给一个二叉树

请把这个棵二叉树按层来打印。如果为相同层，需要从左到右打印。一个节点是先添加左节点后添加右节点，即添加顺序与输入顺序一致。

输入格式
首先输入一个整数T，表示一共有T组数据 0< T < =10

再输入两个整数N,M(0<=N,M<=100)

表示下面有N行，这个树有M个节点(1号节点是这棵树的根节点)

每一行两个整数a,b(1<=a,b<=M)

表示节点a的父亲是节点b

输出格式
对于每组

先输出一行 "Qi:"表示第i个问题

然后接下来输出每个问题二叉树每层的节点，在同一层的节点用空格分开，同一层输出在一行（每一行末尾没有空格），不同的层输出在不同行（入下面Sample Ouput所示）

输入样例
2
4 5
2 1
3 1
4 2
5 4
1 2
2 1
输出样例
Q1:
1
2 3
4
5
Q2:
1
2

#include <iostream>
#include <cstdio>
#include <queue>
#define MAXSIZE 500
using namespace std;
typedef struct BiNode{
    int lc;
    int rc;
    int data;
    int deep; 
    bool turnOn;
    BiNode(){//initiate automatically except data 
        initNode();
    }
    void initNode(){
        turnOn=false;
        deep=-1;
        lc=rc=-1;
    }
}*BiTree;
BiNode Tree[MAXSIZE];
int cursor;
int t,n,m;

//非指定下标地申请结点 
//int createNode(int data){//return the index of new node 
// if (cursor+1==MAXSIZE)
// return -1;//failed
// int nowP=cursor;
// Tree[nowP].turnOn=true;
// cursor++;
// Tree[nowP].data=data;
// Tree[nowP].lc=Tree[nowP].rc=-1;
// return nowP;
//}
int createNode(int index){//return the index of new node 
    Tree[index].data=index;
    Tree[index].turnOn=true;
    Tree[index].lc=Tree[index].rc=-1;
    return index;
}

//用来读取输入建树 
void createTree(){
    int a,b;
    createNode(0);
    scanf("%d%d",&n,&m);
    for (int i=0;i<n;i++){
        scanf("%d%d",&a,&b);
        a--;b--;
        createNode(a);
        if (Tree[b].lc==-1)
            Tree[b].lc=a;
        else
            Tree[b].rc=a;
    }
}
void freeNode(int index){
    Tree[index].initNode();
}
void freeTree(int index){//postOrder
    if (index!=-1){
        //traverse
        freeTree(Tree[index].lc);
        freeTree(Tree[index].rc);
        //visit
        Tree[index].initNode();
    }
}

void levelOrder(int root){//root为从0开始的下标 
    queue<BiNode> q;
    int nowDeep=1;
    bool firstCase=true;
    while (!q.empty())
        q.pop();
    q.push(Tree[root]);
    while (!q.empty()){
        BiNode &nowNode=q.front();
        q.pop();
        if (nowNode.deep!=nowDeep){
            printf("\n");
            nowDeep++;
            firstCase=true;
        }
        if (nowNode.lc!=-1)
            q.push(Tree[nowNode.lc]);
        if (nowNode.rc!=-1)
            q.push(Tree[nowNode.rc]);
        //output
        if (firstCase)
            firstCase=false;
        else
            printf(" ");
        printf("%d",nowNode.data+1);
    }
    printf("\n");
}
void calDeep(int root,int nowDeep){//preOrder
    if (root!=-1){
        Tree[root].deep=nowDeep;
        calDeep(Tree[root].lc,nowDeep+1);
        calDeep(Tree[root].rc,nowDeep+1);
    }
}
void preOrder(int root){
    if (root!=-1){
        cout<<Tree[root].deep<<endl;
        preOrder(Tree[root].lc);
        preOrder(Tree[root].rc);
    }
}
int main(){
    scanf("%d",&t);
    for (int time=0;time<t;time++){
        //initiate
        for (int i=0;i<MAXSIZE;i++){
            Tree[i].initNode();
        }
        cursor=0;
        //input
        createTree();
        //caldeep
        calDeep(0,1);
        //output
        printf("Q%d:\n",time+1);
        levelOrder(0);
// preOrder(0);
    }
    return true;
}