14.6二叉树的层序遍历实战

在14.4，14.5以及13.7的代码基础上写（基于Clion实现）

fuction.h文件

//
// Created by admin on 2024/2/28.
//

#ifndef INC_1_TREE_FUCTION_H
#define INC_1_TREE_FUCTION_H
#include <stdio.h>
#include <stdlib.h>
//function.h文件定义出结构体
typedef char BiElemType;
typedef struct BiTNode{
    BiElemType c;	//c就是data
    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);
#endif //INC_1_TREE_FUCTION_H

queue.cpp文件

//
// Created by admin on 2024/3/2.
//
#include "fuction.h"

//队列的初始化，使用的是带头结点的链表来实现的
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 *s=(LinkNode *)malloc(sizeof(LinkNode));
    s->data=x;s->next=NULL;
    Q.rear->next=s; //rear始终指向尾部
    Q.rear=s;
}
//出队    头部删除法
bool DeQueue(LinkQueue &Q,ElemType &x)
{
    if(Q.front==Q.rear)
        return false;   //队列为空
    LinkNode *q=Q.front->next;  //头结点什么都没存，所以头结点的下一个结点才有数据
    if(Q.rear==q){
        x=q->data;
        Q.rear=Q.front; //如果只有一个结点
    }else{
        x=q->data;
        Q.front->next=q->next;  //断链
    }
    free(q);
    return true;
}

main.cpp文件

#include "fuction.h"
//递归实现  //前序遍历    //abcdefghij前序遍历就是深度优先遍历
void PreOrder(BiTree p)
{
    if(p!=NULL){
        printf("%c",p->c);  //打印根结点
        PreOrder(p->lchild);    //打印左子树
        PreOrder(p->rchild);    //打印右子树
    }
}
//中序遍历
void InOrder(BiTree p)
{
    if(p!=NULL){
        InOrder(p->lchild);    //打印左子树
        printf("%c",p->c);  //打印根结点
        InOrder(p->rchild);    //打印右子树
    }
}
//后序遍历
void PostOrder(BiTree p)
{
    if(p!=NULL){
        PostOrder(p->lchild);    //打印左子树
        PostOrder(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);//等价于printf("%c",c);
        if(p->lchild){
            EnQueue(Q,p->lchild);//左孩子不为空，入队左孩子
        }
        if(p->rchild){
            EnQueue(Q,p->rchild);//右孩子不为空，入队右孩子
        }
    }
}
int main() {
    //树结构
    BiTree pnew; //pnew用来申请新的树结点
    BiTree tree=NULL;	//tree用来指向树根
    BiElemType c;	//字符类型
    //辅助队列结构
    ptag_t phead;	//头指针
    ptag_t ptail;	//尾指针
    ptag_t listpnew;//指向新结点的指针
    ptag_t pcur;	//指向二叉树中父亲结点的指针,用来判断左右孩子是否为空
    phead=ptail=listpnew=pcur=NULL;	//初始化

    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=ptail=pcur=listpnew; //最开始，所有指针都指向第一个辅助队列结点
        }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就指向下一个
            }
        }
    }
    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;
}

输入：

abcdefghij

输出：

------------PreOrder__________
abdhiejcfg
------------InOrder__________ 
hdibjeafcg
------------PostOrder__________
hidjebfgca
------------LevelOrder__________
abcdefghij
进程已结束,退出代码0