二叉树遍历

描述

给定一颗二叉树，要求输出遍历该二叉树得到的先序、中序、后序遍历序列。本题假设二叉树的结点数不超过1000。

输入

输入数据分为多组，第一行是测试数据的组数n，下面的n行分别代表一棵二叉树。每棵二叉树的结点均为正整数，数据为0代表当前结点为空，数据为-1代表二叉树数据输入结束，-1不作处理。二叉树的构造按照层次顺序（即第1层1个整数，第2层2个，第3层4个，第4层有8个......，如果某个结点不存在以0代替）

输出

输出每棵二叉树的先序、中序、后序遍历序列，每个序列占一行。

样例输入

2
1 -1
1 2 3 4 5 0 6 -1

样例输出

 1
 1
 1
 1 2 4 5 3 6
 4 2 5 1 3 6
 4 5 2 6 3 1

提示：输出的每个节点值前有一个空格。

二叉树还没学会，先把大佬的代码拿来先研究一下吧。

#include<bits/stdc++.h>
using namespace std; 
typedef struct BinaryTree
{
    int data;
    BinaryTree *left, *right;
}tree;
tree a[2222];
int n;
//int a[2222],n;
/*
void CreateTree(tree *&T, int k)   //递归创建二叉树 
{
    if(a[k]==0||k>n)
    {
        T=NULL;
        return ;
    }
    else
    {
        T=(tree*)malloc(sizeof(tree));
        T->data=a[k];
        creat(T->left, 2*k);
        creat(T->right, 2*k+1);
    }
    return ;
}*/
void visit(tree *b)
{
    if(b->data!=0)
    printf(" %d", b->data);
    return ;
}
void PreOrderTraverse(tree *t)  //先序遍历递归算法
{
    if (t){
        visit(t);
        PreOrderTraverse(t->left);
        PreOrderTraverse(t->right);
    }
    return ;
}
void InOrderTraverse(tree *t)   //中序遍历递归算法
{
    if (t){
        InOrderTraverse(t->left);
        visit(t);
        InOrderTraverse(t->right);
    }
    return ;
}
void PostOrderTraverse(tree *t)   //后序遍历递归算法
{
    if (t) {
        PostOrderTraverse(t->left);
        PostOrderTraverse(t->right);
        visit(t);
    }
    return ;
}
void LevelOrderTraverse(tree *t)   //层序遍历算法
{
    queue<tree*>q;
    q.push(t);
    while(!q.empty()){
        tree* t = q.front();
        q.pop();
        visit(t);
        if(t->left)q.push(t->left);
        if(t->right)q.push(t->right);
    }
    return ;
}
int main()
{
    int T,k;
    while (~scanf("%d", &T))
    {
        while (T--)
        {
            n = 0;
            while (scanf("%d", &k), k != -1)
                a[n++].data = k;
            k = 1;
            for (int j = 0;j < n;j++)
            {
                if (j + k >= n)a[j].left = NULL;
                else a[j].left = &a[j + k];
                if (j + k + 1 >= n)a[j].right = NULL;
                else a[j].right = &a[j + k + 1];
                k++;
            }
            PreOrderTraverse(a);
            printf("
");
            InOrderTraverse(a);
            printf("
");
            PostOrderTraverse(a);
            printf("
");
            LevelOrderTraverse(a);
            printf("
");
        }
    }
    return 0;
}