二叉树层序遍历，不知道错在哪了

if(p->lchrid!=NULL){
            EnQueue(Q,p->lchrid);
        } 

#include<stdio.h>
#include<stdlib.h>
//树 
typedef char BiElemType; 
typedef struct BiLNode{
    BiElemType x;
    struct BiLNode *lchrid;
    struct BiLNode *rchrid;
}BiLNode,*BiTree;
//辅助队列
typedef struct tag{
    BiTree p;
    struct tag *pnext;
}tag_t,*ptag_t;

//队列
typedef int ElemType; 
typedef struct LinkNode{
    ElemType data;
    struct LinkNode *next;
}LinkNode;
 typedef struct LinkQueue{
     LinkNode *front;
    LinkNode *rear;  
 }LinkQueue;
//初始化队列
void Init_Queue(LinkQueue &Q){
    Q.front = Q.rear = (LinkNode*)malloc(sizeof(LinkNode));
    Q.front->next = NULL;
}
//判断是否为空
bool empty_Queue(LinkQueue Q){
    if(Q.front==Q.rear){
        return true;
    }else{
        return false;
    }
}
//入队
bool EnQueue(LinkQueue &Q,ElemType x){
    LinkNode *pnew;
    pnew = (LinkNode*)malloc(sizeof(LinkNode));
    pnew->data = x;
    pnew->next = NULL;
    Q.rear->next = pnew;
    Q.rear = pnew;
    return true;
}
//出队
bool DeQueue(LinkQueue &Q,ElemType &x){
    if(empty_Queue(Q)){
        return false;
    }
    LinkNode *q;
    q = Q.front->next;
    x = q->data;
    Q.front->next = q->next;
    if(Q.rear == q){
        Q.front = Q.rear;
    }
    free(q);
    return true;
} 

//前序遍历
void Preorder(BiTree tree){
    if(tree!=NULL){
        printf("%c",tree->x);//当前结点 
        Preorder(tree->lchrid);//左孩子
        Preorder(tree->rchrid);//右孩子 
    }
} 
//中序遍历
void Inorder(BiTree tree){
    if(tree!=NULL){
        Inorder(tree->lchrid);//左孩子
        printf("%c",tree->x);//当前结点 
        Inorder(tree->rchrid);//右孩子 
    }
} 
//后序遍历
void Postorder(BiTree tree){
    if(tree!=NULL){
        Postorder(tree->lchrid);//左孩子
        Postorder(tree->rchrid);//右孩子
        printf("%c",tree->x);//当前结点  
    }
} 

//层序遍历，又叫广度优先遍历（前序遍历，又叫深度优先遍历）
void leveorder(BiTree T){
    //1.创建队列
    LinkQueue Q;
    //初始化队列
    Init_Queue(Q);
    BiTree p;//储存出队结点
    EnQueue(Q,T);
    while(!empty_Queue){
        DeQueue(Q,p);
        putchar(p->x);//等价于printf("%c",c);
        if(p->lchrid!=NULL){
            EnQueue(Q,p->lchrid);
        }
        if(p->rchrid!=NULL){
            EnQueue(Q,p->rchrid);
        }  
    } 
} 
int main(){
        //1.定义树
    BiTree tree=NULL;
    BiTree pnew;
    char x;
    //定义辅助队列
    ptag_t phead=NULL;
    ptag_t ptail=NULL;
    ptag_t listpnew=NULL;
    ptag_t pcur=NULL;
    while(scanf("%c",&x)){
        //1.输入中断条件
        if(x=='\n'){
            break;
        }
        pnew = (BiTree)calloc(1,sizeof(BiLNode));
        pnew->x = x;
        listpnew = (ptag_t)calloc(1,sizeof(tag_t));
        listpnew->p = pnew;
        //判断头结点是否为空
        if(tree==NULL) {
            tree = pnew;
            phead = listpnew;
            ptail = listpnew;
            pcur = listpnew;
        }else{
            //若是树根节点已经输入,申请新结点 
            ptail->pnext = listpnew;
            ptail = listpnew;
            //放入元素b
            if(pcur->p->lchrid==NULL){
                pcur->p->lchrid = pnew;
            }else if(pcur->p->rchrid==NULL){
                pcur->p->rchrid = pnew;
            } 
        }
    }
    printf("--------Preorder---------\n");//前序遍历又叫深度优先遍历
    //前序遍历，先打印当前，再左再右 
    Preorder(tree);
    printf("--------Preorder---------\n");
    //中序遍历，先打印左，再当前再右 
    Inorder(tree);
    printf("--------Preorder---------\n");
    //后序遍历，先打印左，再右再当前 
    Postorder(tree);
    printf("--------levelorder---------\n");
    levelorder(tree); 
    return 0; 
} 

这个是完整代码

以下标注了 修改的就是要改的地方：

 
#include<stdio.h>
#include<stdlib.h>
//树 
typedef char BiElemType; 
typedef struct BiLNode{
    BiElemType x;
    struct BiLNode *lchrid;
    struct BiLNode *rchrid;
}BiLNode,*BiTree;
//辅助队列
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 LinkQueue{
     LinkNode *front;
    LinkNode *rear;  
 }LinkQueue;
//初始化队列
void Init_Queue(LinkQueue &Q){
    Q.front = Q.rear = (LinkNode*)malloc(sizeof(LinkNode));
    Q.front->next = NULL;
}
//判断是否为空
bool empty_Queue(LinkQueue Q){
    if(Q.front==Q.rear){
        return true;
    }else{
        return false;
    }
}
//入队
bool EnQueue(LinkQueue &Q,ElemType x){
    LinkNode *pnew;
    pnew = (LinkNode*)malloc(sizeof(LinkNode));
    pnew->data = x;
    pnew->next = NULL;
    Q.rear->next = pnew;
    Q.rear = pnew;
    return true;
}
//出队
bool DeQueue(LinkQueue &Q,ElemType &x){
    if(empty_Queue(Q)){
        return false;
    }
    LinkNode *q;
    q = Q.front->next;
    x = q->data;
    Q.front->next = q->next;
    if(Q.rear == q){
        Q.front = Q.rear;
    }
    free(q);
    return true;
} 
 
//前序遍历
void Preorder(BiTree tree){
    if(tree!=NULL){
        printf("%c",tree->x);//当前结点 
        Preorder(tree->lchrid);//左孩子
        Preorder(tree->rchrid);//右孩子 
    }
} 
//中序遍历
void Inorder(BiTree tree){
    if(tree!=NULL){
        Inorder(tree->lchrid);//左孩子
        printf("%c",tree->x);//当前结点 
        Inorder(tree->rchrid);//右孩子 
    }
} 
//后序遍历
void Postorder(BiTree tree){
    if(tree!=NULL){
        Postorder(tree->lchrid);//左孩子
        Postorder(tree->rchrid);//右孩子
        printf("%c",tree->x);//当前结点  
    }
} 
 
//层序遍历，又叫广度优先遍历（前序遍历，又叫深度优先遍历）
void levelorder(BiTree T){ // 名称修改
    //1.创建队列
    LinkQueue Q;
    //初始化队列
    Init_Queue(Q);
    BiTree p;//储存出队结点
    EnQueue(Q,T);
    while(!empty_Queue(Q)){ // 修改
        DeQueue(Q,p);
        putchar(p->x);//等价于printf("%c",c);
        if(p->lchrid!=NULL){
            EnQueue(Q,p->lchrid);
        }
        if(p->rchrid!=NULL){
            EnQueue(Q,p->rchrid);
        }  
    } 
} 
int main(){
        //1.定义树
    BiTree tree=NULL;
    BiTree pnew;
    char x;
    //定义辅助队列
    //ptag_t phead=NULL;
    ptag_t ptail=NULL;
    ptag_t listpnew=NULL;
    ptag_t pcur=NULL;
    while(scanf("%c",&x)){
        //1.输入中断条件
        if(x=='\n'){
            break;
        }
        pnew = (BiTree)calloc(1,sizeof(BiLNode));
        pnew->x = x;
        listpnew = (ptag_t)calloc(1,sizeof(tag_t));
        listpnew->p = pnew;
        //判断头结点是否为空
        if(tree==NULL) {
            tree = pnew;
            //phead = listpnew;
            ptail = listpnew;
            pcur = listpnew;
        }else{
            //若是树根节点已经输入,申请新结点 
            ptail->pnext = listpnew;
            ptail = listpnew;
            //放入元素b
            if(pcur->p->lchrid==NULL){
                pcur->p->lchrid = pnew;
            }else if(pcur->p->rchrid==NULL){
                pcur->p->rchrid = pnew;
            } 
        }
    }
    printf("--------Preorder---------\n");//前序遍历又叫深度优先遍历
    //前序遍历，先打印当前，再左再右 
    Preorder(tree);
    printf("\n--------Inorder---------\n"); // 修改
    //中序遍历，先打印左，再当前再右 
    Inorder(tree);
    printf("\n--------Postorder---------\n"); // 修改
    //后序遍历，先打印左，再右再当前 
    Postorder(tree);
    printf("\n--------levelorder---------\n"); // 修改
    levelorder(tree); 
    return 0; 
} 

效果如图 :

修改后代码 如下 : 如有有帮助给个采纳谢谢

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

// 树
typedef char BiElemType;
typedef struct BiLNode {
    BiElemType x;
    struct BiLNode *lchrid;
    struct BiLNode *rchrid;
} BiLNode, *BiTree;

// 辅助队列
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 LinkQueue {
    LinkNode *front;
    LinkNode *rear;
} LinkQueue;

// 初始化队列
void Init_Queue(LinkQueue &Q) {
    Q.front = Q.rear = (LinkNode*)malloc(sizeof(LinkNode));
    Q.front->next = NULL;
}

// 判断是否为空
bool empty_Queue(LinkQueue Q) {
    if(Q.front == Q.rear) {
        return true;
    } else {
        return false;
    }
}

// 入队
bool EnQueue(LinkQueue &Q, ElemType x) {
    LinkNode *pNew;
    pNew = (LinkNode*)malloc(sizeof(LinkNode));
    pNew->data = x;
    pNew->next = NULL;
    Q.rear->next = pNew;
    Q.rear = pNew;
    return true;
}

// 出队
bool DeQueue(LinkQueue &Q, ElemType &x) {
    if(empty_Queue(Q)) {
        return false;
    }
    LinkNode *q;
    q = Q.front->next;
    x = q->data;
    Q.front->next = q->next;
    if(Q.rear == q) {
        Q.front = Q.rear;
    }
    free(q);
    return true;
}

// 前序遍历
void Preorder(BiTree tree) {
    if(tree != NULL) {
        printf("%c",tree->x); // 当前结点
        Preorder(tree->lchrid); // 左孩子
        Preorder(tree->rchrid); // 右孩子
    }
}

// 中序遍历
void Inorder(BiTree tree) {
    if(tree != NULL) {
        Inorder(tree->lchrid); // 左孩子
        printf("%c",tree->x); // 当前结点
        Inorder(tree->rchrid); // 右孩子
    }
}

// 后序遍历
void Postorder(BiTree tree) {
    if(tree != NULL) {
        Postorder(tree->lchrid); // 左孩子
        Postorder(tree->rchrid); // 右孩子
        printf("%c",tree->x); // 当前结点
    }
}

// 层序遍历，又叫广度优先遍历
void levelorder(BiTree T) {
    // 创建队列
    LinkQueue Q;
    // 初始化队列
    Init_Queue(Q);
    BiTree p; // 储存出队结点
    EnQueue(Q, T);
    while(!empty_Queue(Q)) {
        DeQueue(Q, p);
        putchar(p->x); // 等价于printf("%c",c);
        if(p->lchrid != NULL) {
            EnQueue(Q, p->lchrid);
        }
        if(p->rchrid != NULL) {
            EnQueue(Q, p->rchrid);
        }
    }
}

int main() {
    // 定义树
    BiTree tree = NULL;
    BiTree pNew;
    char x;

    // 定义辅助队列
    ptag_t pHead = NULL;
    ptag_t pTail = NULL;
    ptag_t listPnew = NULL;
    ptag_t pCur = NULL;

    while(scanf("%c", &x)) {
        // 输入中断条件
        if(x == '\n') {
            break;
        }
        pNew = (BiTree)calloc(1, sizeof(BiLNode));
        pNew->x = x;
        listPnew = (ptag_t)calloc(1, sizeof(tag_t));
        listPnew->p = pNew;

        // 判断头结点是否为空
        if(tree == NULL) {
            tree = pNew;
            pHead = listPnew;
            pTail = listPnew;
            pCur = listPnew;
        } else {
            // 若是树根节点已经输入,申请新结点
            pTail->pNext = listPnew;
            pTail = listPnew;

            // 放入元素b
            if(pCur->p->lchrid == NULL) {
                pCur->p->lchrid = pNew;
            } else if(pCur->p->rchrid == NULL) {
                pCur->p->rchrid = pNew;
            }
        }
    }

    printf("--------Preorder---------\n");
    // 前序遍历，先打印当前，再左再右
    Preorder(tree);
    printf("\n");

    printf("--------Inorder---------\n");
    // 中序遍历，先打印左，再当前再右
    Inorder(tree);
    printf("\n");

    printf("--------Postorder---------\n");
    // 后序遍历，先打印左，再右再当前
    Postorder(tree);
    printf("\n");

    printf("--------levelorder---------\n");
    levelorder(tree);

    return 0;
}

• 你可以看下这个问题的回答https://ask.csdn.net/questions/7610834
• 我还给你找了一篇非常好的博客，你可以看看是否有帮助，链接：二叉树遍历算法的应用
• 另外, 我还从CSDN技能树中找了一些相关资料给你, 你可以学习下:
• 相关习题: 二叉树的层序遍历
• 相关参考资料: 二叉树的层序遍历
• 除此之外, 这篇博客: 单片机实验五 静态数码管实验中的 二、实验软硬件 部分也许能够解决你的问题, 你可以仔细阅读以下内容或跳转源博客中阅读:
  

• 1.Keil uVision4
  2.PZISP自动下载软件
  3.HC6800S开发板

• 您还可以看一下 孙玖祥老师的图解数据结构与算法课程中的 二维数组的初始化和遍历小节, 巩固相关知识点