二叉樹的層次遍歷

二叉樹的層次遍歷需要用到隊列方面的知識，二叉樹之前已經講過一部分操作，這次主要講二叉樹的層次遍歷

用隊列實現層次遍歷的過程爲：首先將根結點入隊，然後出隊，再將根結點的兩個子節點分別入隊（默認爲先左後右）並判斷節點是否爲空，爲空不進行入隊，不爲空入隊，然後繼續進行出隊操作，再將出隊元素的兩個節點入隊，只要隊列不爲空就持續該操作。

上圖層次遍歷的結果應當爲A B G C D H E F ,下面咱們來看操作

二叉樹

頭文件

#ifndef _TREE_H
#define _TREE_H

#define ElemType char
typedef struct BinTreeNode                //二叉樹節點類型
{
    ElemType data;
    BinTreeNode* leftChild;
    BinTreeNode* rightChild;
}BinTreeNode;
typedef struct          //二叉樹根結點
{
    BinTreeNode* root;
    ElemType ref;
}BinTree;

void InitBinTree(BinTree *t);       //初始化根結點
void CreateBinTree(BinTree* t,const char* &p);
void CreateBinTree(BinTreeNode* &t,const char* &p);
void PreOrder(BinTree* t);      //前序遍歷
void PreOrder(BinTreeNode* t);
void InOrder(BinTree* t);       //中序遍歷
void InOrder(BinTreeNode* t);   
void PosOrder(BinTree* t);      //後序遍歷
void PosOrder(BinTreeNode* t);  
void LevelOrder(BinTree* t);    //層次遍歷
void LevelOrder(BinTreeNode* t);

#endif

函數的實現

#include<iostream>
using namespace std;
#include<assert.h>
#include"Tree.h"
#include"queue.h"
void InitBinTree(BinTree *t)           //初始化根結點
{
    t->root=NULL;
    t->ref='#';
}
void CreateBinTree(BinTree* t)         //創建二叉樹
{
    CreateBinTree(t->root);
}
void CreateBinTree(BinTreeNode* &t)
{
    ElemType item;
    cin>>item;
    if(item=='#')
    {
        t=NULL;
    }
    else
    {
        t=(BinTreeNode*)malloc(sizeof(BinTreeNode));
        assert(t!=NULL);
        t->data=item;
        CreateBinTree(t->leftChild);
        CreateBinTree(t->rightChild);
    }
}
void PreOrder(BinTree* t)              //前序遍歷
{
    PreOrder(t->root);
}
void PreOrder(BinTreeNode* t)
{
    if(t)
    {
        cout<<t->data<<" ";
        PreOrder(t->leftChild);
        PreOrder(t->rightChild);
    }
}
void InOrder(BinTree* t)                //中序遍歷
{
    InOrder(t->root);
}
void InOrder(BinTreeNode* t)
{
    if(t)
    {
        InOrder(t->leftChild);
        cout<<t->data<<" ";
        InOrder(t->rightChild);
    }
}
void PosOrder(BinTree* t)                //後序遍歷
{
    PosOrder(t->root);
}
void PosOrder(BinTreeNode* t)
{
    if(t)
    {
        PosOrder(t->leftChild);
        PosOrder(t->rightChild);
        cout<<t->data<<" ";
    }
}
void LevelOrder(BinTree* t)              //層次遍歷
{
    LevelOrder(t->root);
}
void LevelOrder(BinTreeNode* t)
{
    if(t)                                //判斷根結點是否爲空，不爲空進行操作
    {
        queue q;
        init_queue(&q);
        BinTreeNode* temp=t;
        push(&q,temp);
        while(Emptyqueue(&q)!=1)          //隊列不爲空持續出隊入隊
        {
            pop(&q);
            push(&q,temp->leftChild);       //在push函數中已經設置若節點爲空，則不入隊
            push(&q,temp->rightChild);
            temp=Getfront(&q);
        }
        cout<<endl;
    }
}

隊列

頭文件

#ifndef QUEUE_H
#define QUEUE_H
#include"Tree.h"
#define ElemTypeB BinTreeNode*        //宏定義隊列存儲對像的類型
typedef struct queue
{
    ElemTypeB *base;
    int capacity;
    int front;
    int rear;
}queue;

void init_queue(queue* q);         //初始化隊列

void push(queue* q,ElemTypeB x);    // 入隊

void pop(queue* q);                 //出隊

int Emptyqueue(queue* q);           //判斷隊列是否爲空，爲空返回1，不爲空返回0

ElemTypeB Getfront(queue* q);       //獲取隊列隊頭元素

#endif

函數實現

#include<iostream>
using namespace std;
#include"queue.h"
#include"assert.h"
void init_queue(queue* q)
{
    q->base=(ElemTypeB*)malloc(sizeof(ElemTypeB)*10);
    assert(q->base!=NULL);
    q->capacity=10;
    q->front=q->rear=0;
}
void push(queue* q,ElemTypeB x)
{
    if((q->rear+1)%q->capacity==q->front)         //判斷隊列是否已滿
    {
        cout<<"隊列已滿，無法入隊"<<endl;
        return;
    }
    if(x)                                         //判斷入隊元素是否爲空，不爲空入隊
    {
        q->base[q->rear++]=x;
        q->rear=q->rear%q->capacity;
    }
}
void pop(queue* q)
{
    if(q->front==q->rear)
    {
        cout<<"隊列已空"<<endl;
        return;
    }
    cout<<(q->base[q->front++])->data<<" ";
    q->front%=q->capacity;
}
int Emptyqueue(queue* q)
{
    if(q->front==q->rear)
        return 1;
    return 0;
}
ElemTypeB Getfront(queue* q)
{
    return q->base[q->front];
}

主函數

#include<iostream>
using namespace std;
#include"Tree.h"
#include"queue.h"
int main()
{
    BinTree T;
    InitBinTree(&T);
    CreateBinTree(&T);
    cout<<"Pre:";
    PreOrder(&T);
    cout<<endl;
    cout<<"In:";
    InOrder(&T);
    cout<<endl;
    cout<<"Pos:";
    PosOrder(&T);
    cout<<endl;
    cout<<"Level:";
    LevelOrder(&T);
    cout<<endl;
}

運行結果

和咱們之前預期的結果一樣
再換一組測試數據ABD##E##C#FG##H##
畫出對應樹形圖爲

由樹形圖可以看出層次遍歷的結果應當爲ABCDEFGH
我們來看運行結果