连接表的广度优先遍历

对《大话数据结构》P244——邻接表的广度优先遍历，进行了自己的理解并完善了代码。

举个简单的例子：

首先用邻接表的存储结构创建该图，再进行广度优先遍历。

代码和解释如下（VS2012测试通过）：

#include <iostream>
#include <stdlib.h>
using namespace std;
#define MAXVERTEX 6//定义顶点数最多为6
#define MAXSIZE 6//循环队列的最大长度定义为6

//边表节点
typedef struct EdgeNode
{
    int adjvex;//存储该顶点对应的下标
    struct EdgeNode *next;//指向该顶点的下一个邻接点
}EdgeNode;

//顶点表结点
typedef struct VertexNode
{
    char data;//顶点
    EdgeNode *firstedge;//边表头指针
}VertexNode;

//图的邻接表存储结构
typedef struct
{
    VertexNode adjList[MAXVERTEX];//有6个VertexNode这种类型的顶点，定义一个数组adjList[6]，每个元素是VertexNode类型
    int numVertexes,numEdges;//图中顶点数和边数，这里是6,9
}GraphAdjList;

//无向图的邻接表创建
GraphAdjList *CreateALGraph(GraphAdjList *Gp)
{
    Gp=(GraphAdjList *)malloc(sizeof(GraphAdjList));//申请一片GraphAdjList大小的类型很重要，否则Gp指向NULL（GL传的值是NULL），程序就运行崩溃了
    EdgeNode *pe;//定义边表指针类型pe
    cout << "input numNodes and numEdges:" << endl;
    cin >> Gp->numVertexes >> Gp->numEdges;//输入6 9
    for (int k = 0 ; k < Gp->numVertexes; k++)
    {
        cout << "input VertexType data:" << endl;
        cin >> Gp->adjList[k].data;//输入A B C D E F
        Gp->adjList[k].firstedge = NULL;//将边表头指针指向NULL，即置为0
    }
    for (int k = 0; k < Gp->numEdges; k++)//建立边表
    {
        int i,j;
        cout << "input vi and vj:" << endl;
        cin >> i >> j;//每次循环依次输入0 1，0 3，0 5，1 2，1 3，1 5，2 3，3 4，4 5

        pe = (EdgeNode *)malloc(sizeof(EdgeNode));
        pe->adjvex = j;// 邻接序号为j
        pe->next = Gp->adjList[i].firstedge;//将pe的指针指向当前顶点指向的结点
        Gp->adjList[i].firstedge = pe;//将当前顶点的指针指向pe

        pe = (EdgeNode *)malloc(sizeof(EdgeNode));
        pe->adjvex = i;
        pe->next = Gp->adjList[j].firstedge;
        Gp->adjList[j].firstedge = pe;//无序图重复上面步骤
    }
    return Gp;
}

//循环队列的顺序存储结构
//保留一个元素空间，否则front==rear，是空队列还是满队列不容易判断
typedef struct
{
    char data[MAXSIZE];//队列，用数组形式表示  
    int front;//头序号，第一个元素的下标
    int rear;//尾序号，最后一个元素的下标
}SqQueue;

//循环队列的初始化，返回指向循环队列的地址
SqQueue *InitQueue(SqQueue *Q)
{
    Q=new SqQueue;
    Q->front=0;
    Q->rear=0;//初始化为空队列（front==rear为空队列）
    return Q;
}

//求循环队列的长度，返回循环队列的当前长度
int QueueLength(SqQueue *Q)
{
    return (Q->rear-Q->front+MAXSIZE)%MAXSIZE;
}

//循环队列的入队列操作
void EnQueue(SqQueue *Q,char e)
{
    if((Q->rear+1)%MAXSIZE==Q->front)//判断循环队列是否满
    {
        cout<<"error"<<" ";
        return;
    }
    Q->data[Q->rear]=e;//将元素e插入队尾
    Q->rear=(Q->rear+1)%MAXSIZE;//尾序号rear加1，若到最后转向头部
    cout<<e<<"in"<<" ";
    return;
}

//循环队列的出队列操作
char DeQueue(SqQueue *Q)
{
    char e;
    if(Q->front==Q->rear)//如果队列是否空
    {
        cout<<"error"<<" ";
        return 0;//返回0表示队列空，没有出队元素
    }
    e=Q->data[Q->front];
    Q->front=(Q->front+1)%MAXSIZE;//头序号front加1，若到最后转向头部
    cout<<e<<"out"<<" ";
    return e;
}

//邻接表的广度优先遍历
void BFSTraverse(GraphAdjList *G)
{
    EdgeNode *p;//定义一个指向边表结点的指针
    int visited[MAXVERTEX];//标志顶点是否被访问，0是未被访问过，1是被访问过
    char e;
    
    SqQueue *s=NULL; 
    s=InitQueue(s);//初始化一个循环队列s，最大长度为MAXSIZE=6，初始为空

    for(int i=0;i<G->numVertexes;i++)//初始化所有顶点都未被访问过
        visited[i]=0;

    for(int i=0;i<G->numVertexes;i++)//对于连通图，执行一次就可以遍历所有顶点
    {
        if(!visited[i])//如果没有被访问过，就处理，防止不必要的重复处理
        {
            visited[i]=1;//设置当前顶点访问过
            cout<<"print1"<<G->adjList[i].data<<" ";//打印该顶点
            EnQueue(s,G->adjList[i].data);//把该顶点入队
            while(QueueLength(s))//若当前队列长度不等于0（即不为空）
            {
                e=DeQueue(s);//元素出队，需要知道出队元素的下标，更新i
                switch (e)                  
                {
                    case 'A':i=0;break;
                    case 'B':i=1;break;
                    case 'C':i=2;break;
                    case 'D':i=3;break;
                    case 'E':i=4;break;
                    case 'F':i=5;break;
                    default:break;
                }
                cout<<endl;
                p=G->adjList[i].firstedge;//把刚才出队元素所在的顶点表结点的firstedge的指向给p，即找到与出队元素相连的另一个顶点
                while(p)
                {
                    if(!visited[p->adjvex])//如果找到的这个顶点还没被访问过
                    {
                        visited[p->adjvex]=1;
                        cout<<"print2"<<G->adjList[p->adjvex].data<<" ";//打印这个顶点
                        EnQueue(s,G->adjList[p->adjvex].data);//把该顶点入队
                    }
                    p=p->next;//让p指向下一个边表节点
                }
            }
        }
    }
}

int main(void)
{
    GraphAdjList *p=NULL;
    p=CreateALGraph(p);//创建图
    BFSTraverse(p);//广度遍历 
}

运行结果：

结果解释：

print1和print2用来标记在函数哪个部分打印，可以看出遍历顺序是AFDBEC。

也可以看出入队和出队的顺序。

打印A，A入队，A出队。

打印F，F入队；打印D，D入队；打印B，B入队。F出队。

打印E，E入队。D出队。

打印C，C入队。B出队。

E出队。

C出队。