请问我这个二叉树层次遍历哪里不正确？

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

typedef struct BiTNode{
    char data;
    struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
typedef struct LinkNode{
    BiTNode * data;
    struct LinkNode *next;
}LinkNode;
typedef struct{
    LinkNode *front,*rear;
}LinkQueue;


void InitQueue(LinkQueue Q){
    Q.front=Q.rear=(LinkNode*)malloc(sizeof(LinkNode));
    Q.front->next=NULL;
}

bool IsEmpty(LinkQueue Q){
    if(Q.front==Q.rear) return true;
    else return false;
}

void EnQueue(LinkQueue &Q,BiTree x){
    LinkNode *s=(LinkNode *)malloc(sizeof(LinkNode));
    s->data=x;s->next=NULL;
    Q.rear->next=s;
    Q.rear=s; 
} 

bool DeQueue(LinkQueue &Q,BiTree &x){
    if(Q.front==Q.rear) return false;
    LinkNode *p=Q.front->next;
    x=p->data;
    Q.front->next=p->next;
    if(Q.rear==p){
        Q.rear=Q.front;
    }
    free(p);
    return true;
}

BiTree CreatBiTree(BiTree &T){
    int x;
    printf("请输入\n");
    scanf("%d",&x);
    if(x!=0){
        T=(BiTree)malloc(sizeof(BiTNode));
        T->data=x;
        T->lchild=NULL;
        T->rchild=NULL;
        T->lchild=CreatBiTree(T->lchild);
        T->rchild=CreatBiTree(T->rchild);
    } 
    return T; 
}

void LevelOrder(BiTree T){
    LinkQueue Q;
    InitQueue (Q);;
    BiTree p;
    EnQueue (Q,T);
    while(!IsEmpty(Q)){
        DeQueue(Q,p);
        int a=p->data;
        printf(" %d",a);
        if(p->lchild!=NULL)
          EnQueue(Q,p->lchild);
        if(p->rchild!=NULL)
          EnQueue(Q,p->rchild);
    }
}


int main(){
    BiTree T;
    CreatBiTree(T);
    printf("层次遍历输出\n");
    LevelOrder(T);

return 0;    
}

最后死循环了

参考：

#include<bits/stdc++.h>
using namespace std;
 
typedef struct BNode{
    char data;
    struct BNode *lchild;
    struct BNode *rchild;
}BNode;
 
const int N = 100;
char str[N]; //存储先序遍历序列
int i; //标记处理到哪一个字符了
BNode *BulidTree(){
    if(str[i] == '#'){
        i++; //处理下一个字符
        return NULL;
    }else{
        //新建一个结点
        BNode *p = (BNode *)malloc(sizeof(BNode));
        p->data = str[i];
        p->lchild = NULL;
        p->rchild = NULL;
        i++;
        p->lchild = BulidTree();
        p->rchild = BulidTree();
        return p;
    }
}
 
//非递归算法
int Depth(BNode *root){
    int level = 0; //level为层数
    BNode *last = root;//last为下一层的最右结点
    if(root == NULL){ //树空，则高度为0
        return 0;
    }
    queue<BNode *> treenode; //申请一个队列
    treenode.push(root); //根结点入队
    while(!treenode.empty()){ //队不空时循环
        BNode *p = treenode.front(); //队首
        treenode.pop(); //根结点出队
        if(p->lchild != NULL){ //如果存在左子树，则左子树根结点入队
            treenode.push(p->lchild);
        }
        if(p->rchild != NULL){ //如果存在右子树，则右子树根结点入队
            treenode.push(p->rchild);
        }
        if(p == last){ //如果刚才出队的是该层最右结点
            level++; //层数加1
            last = treenode.back(); //last指向下层
        }
    }
    return level;
}
 
//递归算法
// int Depth2(BNode *root){
//     if(root == NULL){ //空树，高度为0
//         return 0;
//     }
//     int left = Depth2(root->lchild); //左子树高度
//     int right = Depth2(root->rchild); //右子树高度
//     return (left>right? left+1 : right+1); //树的高度为最大子树的高度加上根结点
// }
 
int main(){
    scanf("%s",str);
    i = 0;
    BNode *root = BulidTree();
    int level = Depth(root);
    printf("%d\n",level);
    return 0;
}