数据结构——二叉树的层序遍历

基于前几篇代码的复用

function.h

//
// Created by 嗯哼 on 1/27/2024.
//

#ifndef UNTITLED13_FUNCTION_H
#define UNTITLED13_FUNCTION_H
#include <stdio.h>
#include <stdlib.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 //UNTITLED13_FUNCTION_H

queue.cpp

//
// Created by 嗯哼 on 1/27/2024.
//
#include "function.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 *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;
}
//通过链表来实现队列

main.cpp

#include "function.h"

//前序遍历即先序遍历即深度优先遍历
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;//用来指向新申请的树节点
    BiTree tree=NULL;//tree是指向树根的，代表树
    char c;
    ptag_t phead=NULL,ptail=NULL,listpnew=NULL,pcur;
    //w
    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;//pcur->p 左孩子为空,就放入左孩子
            }else if(NULL==pcur->p->rchild)
            {
                pcur->p->rchild=pnew;//pcur->p 右孩子为空,就放入右孩子
                pcur=pcur->pnext;//当前节点已经满了，pcur就指向下一个
            }
        }
    }
    printf("--------------PreOrder-------------\n");//先序遍历，先打印当前结点，打印左右孩子
    PreOrder(tree);
    printf("\n--------------PreOrder-------------\n");//先打印左孩子，打印父亲，打印右孩子
    InOrder(tree);
    printf("\n--------------PreOrder-------------\n");//先打印左孩子，打印右孩子，最后打印父亲
    PostOrder(tree);
    printf("\n--------------LevelOrder-------------\n");//
    LevelOrder(tree);
    return 0;
}