队列的应用——(二)实现树的层序遍历(树的初体验)

现在一棵树，如下图所示，利用队列思想实现层序遍历。就是指 A - B - C - D - F - J - K，一层一层遍历。

代码如下：（C++）

myqueue.h

#include<stdio.h>
#include<stdlib.h>
struct TreeNode
{
        char _data;
        TreeNode*_left;
        TreeNode*_right;
};
struct  Node
{
        TreeNode* data;  //这里要压入的是一个指针
        Node* next;
};

struct Queue
{
        Node*front;
        Node*rear;
};

void initQueue(Queue*q);
bool enQueueEmpty(Queue*q);
void enQueue(Queue*q,TreeNode* ch);
TreeNode* deQueue(Queue*q);
void resetQueue(Queue*q);
void destroyQueue(Queue*q);

 

myqueue.cpp

#include"myqueue.h"
void initQueue(Queue*q)
{
    q->front = q->rear = (Node*)malloc(sizeof(Node));
    q->front->next=NULL;
}
bool enQueueEmpty(Queue*q)
{
    return q->front==q->rear;
}
void enQueue(Queue*q,TreeNode* ch)
{
    Node*cur= (Node*)malloc(sizeof(Node));
    cur->data=ch;
    cur->next=NULL;                   //在尾巴

    q->rear->next=cur;
    q->rear=cur;                           //让rear始终指向最后一个
}
TreeNode *deQueue(Queue*q)
{
    TreeNode* ch = q->front->next->data;
    if(q->front->next == q->rear)  //若两者相等，则队列为空
    {
        q->rear = q->front;
        free(q->front->next);
        q->front->next=NULL;      //置为空
    }
    else                                     //若不是相等，就是正常的节点脱离
    {
        Node*t=q->front->next;
        q->front->next=t->next;
        free(t);
    }
    return ch;
}
void resetQueue(Queue*q)
{
    Node* head=q->front->next;
    q->front->next=NULL;          //将链表一分为二
    q->rear=q->front;
    Node*t;
    while(head)
    {
        t=head->next;
        free(head);
        head=t;
    }
}
void destroyQueue(Queue*q)  //销毁所有
{
    resetQueue(q);
    free(q->front);
}

main函数

#include<stdlib.h>
#include<stdio.h>
#include"myqueue.h"
int main()
{
    TreeNode a,b,c,d,f,j,k;  //实现一棵树
    TreeNode *root = &a;  //根
    a._data = 'A';
    b._data = 'B';
    c._data = 'C';
    d._data = 'D';
    f._data = 'F';
    j._data = 'J';
    k._data = 'K';

    a._left = &b;
    a._right = &c;

    b._left = &d;
    b._right = NULL;  //这里分支如果没有则置为空
    d._left = d._right = NULL;

    c._left = &f;
    c._right = NULL;

    f._left = &j;
    f._right = &k;

    j._left = j._right = k._left = k._right  = NULL;

    //开始遍历
    Queue q;
    initQueue(&q);
    enQueue(&q,root);//根入队
    while(!enQueueEmpty(&q))
    {
        TreeNode* t = deQueue(&q); //出队
        printf("%c ",t->_data);
        if(t->_left)
        {
             enQueue(&q,t->_left);
        }
        if(t->_right)
        {
              enQueue(&q,t->_right);
        }
    }
    return 0;
}

while循环的思想

这里举例来说就是：若A入队，然后出队并打印它的char，然后它的左右节点若存在，则 B和 C入队，由于左节点 B 先入队则先出队,打印出char，然后再判断左右有没有存在节点，只存在D，存在则入队。

之后则是上一次进入的C出队，然后打印出C，继续判断 C 的左右节点，只存在 F,则F入队，然后继续循环，D出队，打印出D,判断D左右节点，都没有。进入下一循环，即 F出队打印 F，继而判断F左右，这样继续循环即可。