读取字符串abcdefghij，然后层次建树建立一颗二叉树，然后中序遍历输出 hdibjeafcg，后序遍历输出 hidjebfgca，层序遍历输出abcdefghij

#include <stdio.h>
#include <stdlib.h>


typedef char BiElemType;
typedef struct BiTNode{
    BiElemType c;
    struct BiTNode *lchild;
    struct BiTNode *rchild;
}BiTNode,*Bitree;

//tag结构体是辅助队列使用的
typedef struct tag{
    Bitree p;//树的某一个结点的地址值
    struct tag *pnext;
}tag_t,*ptag_t;

//队列的结构体
typedef Bitree ElemType;
typedef struct LinkNode{
    ElemType data;
    struct LinkNode *next;
}LinkNode;
typedef struct{
    LinkNode *front,*rear;//链表头、链表尾（队头队尾）
}LinkQueue;
void InitQueue(LinkQueue &Q);
bool IsEmpty(LinkQueue Q);
void EnQueue(LinkQueue &Q,ElemType x);
bool DeQueue(LinkQueue &Q,ElemType &x);

//前序遍历,也叫先序遍历，也叫深度优先遍历
void PreOder(Bitree p)
{
    if(p!=NULL)
    {
        printf("%c",p->c);
        PreOder(p->lchild);//打印左子树
        PreOder(p->rchild);//打印右子树
    }
}

//中序遍历
void InOder(Bitree p)
{
    if(p!=NULL)
    {
        InOder(p->lchild);//打印左子树
        printf("%c",p->c);
        InOder(p->rchild);//打印右子树
    }
}

//后序遍历
void PostOder(Bitree p)
{
    if(p!=NULL)
    {
        PostOder(p->lchild);//打印左子树
        PostOder(p->rchild);//打印右子树
        printf("%c",p->c);
    }
}

//层序遍历
void LevelOrder(Bitree T)
{
    LinkQueue Q;//辅助队列
    InitQueue(Q);//初始化队列
    Bitree p;
    EnQueue(Q,T);//树根入队
    while (!IsEmpty(Q))
    {
        DeQueue(Q,p);//出队当前结点并打印
        putchar(p->c);
        if(p->lchild != NULL)//入队左孩子
            EnQueue(Q,p->lchild);
        if(p->rchild != NULL)//入队右孩子
            EnQueue(Q,p->rchild);
    }

}

//队列的初始化，使用的是带头结点的链表来实现的
void InitQueue(LinkQueue &Q)
{
    Q.front = Q.rear = (LinkNode*) malloc(sizeof (LinkNode));
    Q.front->next = NULL;
}

//判断队列是否为空
bool IsEmpty(LinkQueue Q)
{
    return Q.rear == Q.front;
}

//入队
void EnQueue(LinkQueue &Q,ElemType x)
{
    LinkNode *pnew = (LinkNode*) malloc(sizeof(LinkNode));
    pnew->data = x;
    pnew->next = NULL;//要让next为NULL
    Q.rear->next = pnew;//尾指针的next指向pnew，因为从尾部入队
    Q.rear = pnew;//rear指向新的尾部
}

//出队
bool DeQueue(LinkQueue &Q,ElemType &x)
{
    if(Q.rear == Q.front)
    {
        return false;
    }
    LinkNode *q = Q.front->next;//拿到第一个结点，存入q
    x = q->data;//获取要出队的元素值
    Q.front->next = q->next;//让一个结点断链
    if(Q.rear == q)//链表只剩一个结点时，被删除后，要改变rear
    {
        Q.rear = Q.front;
    }
    free(q);
    return true;
}


int main() {
    Bitree pnew;//用来指向新申请的树结点
    Bitree tree = NULL;
    char c;
    ptag_t phead = NULL, ptail = NULL, listpnew = NULL,pcur;
    //读取abcdefghij
    while (scanf("%c",&c))
    {
        if(c == '\n')
        {
            break;//读到换行就结束
        }
        //calloc申请的空间是两个参数直接相乘，并对空间进行初始化，赋值为0
        pnew = (Bitree)calloc(1,sizeof(BiTNode));
        pnew->c = c;
        //给队列结点申请空间
        listpnew = (ptag_t)calloc(1,sizeof (tag_t));
        listpnew->p = pnew;
        //如果是树的第一个结点
        if(NULL == tree)
        {
            tree = pnew;//tree指向树的根结点
            phead = listpnew;//第一个结点既是队列头，也是队列尾
            ptail = listpnew;
            pcur = listpnew;//pcur要指向：要进入树的父亲元素
        } else{
            //让元素先入队列
            ptail ->pnext = listpnew;
            ptail = listpnew;
            //接下来把b结点放入树中
            if(NULL == pcur->p->lchild)
            {
                pcur->p->lchild = pnew;//左孩子为空，就放入左孩子
            }else if(NULL == pcur->p->rchild)
            {
                pcur->p->rchild = pnew;//右孩子为空，放入右孩子
                pcur = pcur->pnext;//当前结点左右孩子都有了，pcur指向下一个
            }

        }
    }
    //中序遍历
    InOder(tree);
    printf("\n");
    //后序遍历
    PostOder(tree);
    printf("\n");
    //层序遍历
    LevelOrder(tree);
    printf("\n");
    return 0;
}