C++二叉树的广度优先遍历算法

建立一个function.h头文件，写入用到的其他文件，定义二叉树，定义队列的数据结构：

#ifndef INC_2_FUNCTION_H
#define INC_2_FUNCTION_H
#include <string>
#include <stdlib.h>
//二叉树数据结构
typedef char Elemtype;
typedef struct BitNode{
    Elemtype c;
    struct BitNode *LChild;
    struct BitNode *RChild;
}BitNode,*BitPointer;
//二叉树辅助队列数据结构
typedef struct tag{
    BitPointer p;
    struct tag *pnext;
}tag,*PTag;
//层序遍历辅助队列数据结构
typedef BitPointer QElemType;
typedef struct Queue{
    QElemType data;
    struct Queue *next;
}Queue;
typedef struct QPointer{
    Queue *front,*rare;
}QPointer;
bool InitQueue(QPointer &L);
bool EnQueue(QPointer &L,QElemType x);
bool DeQueue(QPointer &L,QElemType &index);
bool IsEmpty(QPointer L);
#endif //INC_2_FUNCTION_H

新建一个Queue.cpp源文件定义建立辅助队列所需要的函数：

#include "function.h"
bool InitQueue(QPointer &L){
    L.front=L.rare=(Queue*) malloc(sizeof (Queue));
    L.rare->next=NULL;
    return true;
}

bool EnQueue(QPointer &L,QElemType x){
    Queue *NewNode;
    NewNode=(Queue *) malloc(sizeof (Queue));
    NewNode->data=x;
    NewNode->next=NULL;
    L.rare->next=NewNode;
    L.rare=NewNode;
    return true;
}

bool DeQueue(QPointer &L,QElemType &index){
    if (L.rare==L.front){
        return false;
    }
    Queue *TronPointer;
    TronPointer=L.front->next;
    index=TronPointer->data;
    L.front->next=TronPointer->next;
    if (L.rare==TronPointer){
        L.rare=L.front;
    }
    free(TronPointer);
    return true;
}

bool IsEmpty(QPointer L){
    if (L.rare==L.front){
        return true;
    } else{
        return false;
    }
}

在主函数中实现二叉树的遍历：

//层序遍历
void SequenceTree(BitPointer roots){
    QPointer Q;
    InitQueue(Q);
    BitPointer TronTree;
    EnQueue(Q,roots);
    while (!IsEmpty(Q)){
        DeQueue(Q,TronTree);
        putchar(TronTree->c);
        if (TronTree->LChild!=NULL){
            EnQueue(Q,TronTree->LChild);
        }
        if (TronTree->RChild!=NULL){
        EnQueue(Q,TronTree->RChild);
        }
    }

}

int main() {
    BitPointer NewNode;
    BitPointer tree=NULL;
    Elemtype c;
    PTag QueueHead=NULL,QueueTail=NULL,QueueNode=NULL,Pcur=NULL;
    while (scanf("%c",&c)){
        if (c=='\n'){
            break;
        }
        NewNode=(BitPointer) calloc(1,sizeof (BitNode));
        QueueNode=(PTag) calloc(1,sizeof (tag));
        NewNode->c=c;
        QueueNode->p=NewNode;
        if (tree==NULL){
            tree=NewNode;
            QueueHead=QueueNode;
            QueueTail=QueueNode;
            Pcur=QueueNode;
            continue;
        }else{
            QueueTail->pnext=QueueNode;
            QueueTail=QueueNode;
        }
        if (Pcur->p->LChild==NULL){
            Pcur->p->LChild=NewNode;
        } else if (QueueNode->p->RChild == NULL){
            Pcur->p->RChild=NewNode;
            Pcur=Pcur->pnext;
        }
    }

    SequenceTree(tree);
    return 0;
}