图——图的遍历—— 广度优先遍历BFS

/*
*Copyright (c) 2015 , 烟台大学计算机学院
*All right resvered .
*文件名称: 广度优先遍历BFS.cpp
*作    者: 郑兆涵
*图——图的遍历—— 广度优先遍历BFS
*/

问题：实现图遍历算法，输出广度优先遍历BFS

以下图为例：



编程代码：

//头文件：graph.h，包含定义图数据结构的代码、宏定义、要实现算法的函数的声明
#ifndef GRAPH_H_INCLUDED
#define GRAPH_H_INCLUDED

#define MAXV 100                //最大顶点个数
#define INF 32767       //INF表示∞
typedef int InfoType;

//以下定义邻接矩阵类型
typedef struct
{
int no;                     //顶点编号
InfoType info;              //顶点其他信息，在此存放带权图权值
} VertexType;                   //顶点类型

typedef struct                  //图的定义
{
int edges[MAXV][MAXV];      //邻接矩阵
int n,e;                    //顶点数，弧数
VertexType vexs[MAXV];      //存放顶点信息
} MGraph;                       //图的邻接矩阵类型

//以下定义邻接表类型
typedef struct ANode            //弧的结点结构类型
{
int adjvex;                 //该弧的终点位置
struct ANode *nextarc;      //指向下一条弧的指针
InfoType info;              //该弧的相关信息,这里用于存放权值
} ArcNode;

typedef int Vertex;

typedef struct Vnode            //邻接表头结点的类型
{
Vertex data;                //顶点信息
int count;                  //存放顶点入度,只在拓扑排序中用
ArcNode *firstarc;          //指向第一条弧
} VNode;

typedef VNode AdjList[MAXV];    //AdjList是邻接表类型

typedef struct
{
AdjList adjlist;            //邻接表
int n,e;                    //图中顶点数n和边数e
} ALGraph;                      //图的邻接表类型

//功能：由一个反映图中顶点邻接关系的二维数组，构造出用邻接矩阵存储的图
//参数：Arr - 数组名，由于形式参数为二维数组时必须给出每行的元素个数，在此将参数Arr声明为一维数组名（指向int的指针）
//      n - 矩阵的阶数
//      g - 要构造出来的邻接矩阵数据结构
void ArrayToMat(int *Arr, int n, MGraph &g); //用普通数组构造图的邻接矩阵
void ArrayToList(int *Arr, int n, ALGraph *&); //用普通数组构造图的邻接表
void MatToList(MGraph g,ALGraph *&G);//将邻接矩阵g转换成邻接表G
void ListToMat(ALGraph *G,MGraph &g);//将邻接表G转换成邻接矩阵g
void DispMat(MGraph g);//输出邻接矩阵g
void DispAdj(ALGraph *G);//输出邻接表G

#endif // GRAPH_H_INCLUDED

//源文件：graph.cpp，包含实现各种算法的函数的定义
#include <stdio.h>
#include <malloc.h>
#include "graph.h"

//功能：由一个反映图中顶点邻接关系的二维数组，构造出用邻接矩阵存储的图
//参数：Arr - 数组名，由于形式参数为二维数组时必须给出每行的元素个数，在此将参数Arr声明为一维数组名（指向int的指针）
//      n - 矩阵的阶数
//      g - 要构造出来的邻接矩阵数据结构
void ArrayToMat(int *Arr, int n, MGraph &g)
{
int i,j,count=0;  //count用于统计边数，即矩阵中非0元素个数
g.n=n;
for (i=0; i<g.n; i++)
for (j=0; j<g.n; j++)
{
g.edges[i][j]=Arr[i*n+j]; //将Arr看作n×n的二维数组，Arr[i*n+j]即是Arr[i][j]，计算存储位置的功夫在此应用
if(g.edges[i][j]!=0)
count++;
}
g.e=count;
}

void ArrayToList(int *Arr, int n, ALGraph *&G)
{
int i,j,count=0;  //count用于统计边数，即矩阵中非0元素个数
ArcNode *p;
G=(ALGraph *)malloc(sizeof(ALGraph));
G->n=n;
for (i=0; i<n; i++)                 //给邻接表中所有头节点的指针域置初值
G->adjlist[i].firstarc=NULL;
for (i=0; i<n; i++)                 //检查邻接矩阵中每个元素
for (j=n-1; j>=0; j--)
if (Arr[i*n+j]!=0)      //存在一条边，将Arr看作n×n的二维数组，Arr[i*n+j]即是Arr[i][j]
{
p=(ArcNode *)malloc(sizeof(ArcNode));   //创建一个节点*p
p->adjvex=j;
p->info=Arr[i*n+j];
p->nextarc=G->adjlist[i].firstarc;      //采用头插法插入*p
G->adjlist[i].firstarc=p;
}

G->e=count;
}

void MatToList(MGraph g, ALGraph *&G)
//将邻接矩阵g转换成邻接表G
{
int i,j;
ArcNode *p;
G=(ALGraph *)malloc(sizeof(ALGraph));
for (i=0; i<g.n; i++)                   //给邻接表中所有头节点的指针域置初值
G->adjlist[i].firstarc=NULL;
for (i=0; i<g.n; i++)                   //检查邻接矩阵中每个元素
for (j=g.n-1; j>=0; j--)
if (g.edges[i][j]!=0)       //存在一条边
{
p=(ArcNode *)malloc(sizeof(ArcNode));   //创建一个节点*p
p->adjvex=j;
p->info=g.edges[i][j];
p->nextarc=G->adjlist[i].firstarc;      //采用头插法插入*p
G->adjlist[i].firstarc=p;
}
G->n=g.n;
G->e=g.e;
}

void ListToMat(ALGraph *G,MGraph &g)
//将邻接表G转换成邻接矩阵g
{
int i,j;
ArcNode *p;
g.n=G->n;   //根据一楼同学“举报”改的。g.n未赋值，下面的初始化不起作用
g.e=G->e;
for (i=0; i<g.n; i++)   //先初始化邻接矩阵
for (j=0; j<g.n; j++)
g.edges[i][j]=0;
for (i=0; i<G->n; i++)  //根据邻接表，为邻接矩阵赋值
{
p=G->adjlist[i].firstarc;
while (p!=NULL)
{
g.edges[i][p->adjvex]=p->info;
p=p->nextarc;
}
}
}

void DispMat(MGraph g)
//输出邻接矩阵g
{
int i,j;
for (i=0; i<g.n; i++)
{
for (j=0; j<g.n; j++)
if (g.edges[i][j]==INF)
printf("%3s","∞");
else
printf("%3d",g.edges[i][j]);
printf("\n");
}
}

void DispAdj(ALGraph *G)
//输出邻接表G
{
int i;
ArcNode *p;
for (i=0; i<G->n; i++)
{
p=G->adjlist[i].firstarc;
printf("%3d: ",i);
while (p!=NULL)
{
printf("-->%d/%d ",p->adjvex,p->info);
p=p->nextarc;
}
printf("\n");
}
}

//编制main函数，完成相关的测试工作。
#include <stdio.h>
#include <malloc.h>
#include "graph.h"

void BFS(ALGraph *G, int v)
{
ArcNode *p;
int w,i;
int queue[MAXV],front=0,rear=0; //定义循环队列
int visited[MAXV];     //定义存放节点的访问标志的数组
for (i=0; i<G->n; i++) visited[i]=0; //访问标志数组初始化
printf("%2d",v);            //输出被访问顶点的编号
visited[v]=1;                       //置已访问标记
rear=(rear+1)%MAXV;
queue[rear]=v;              //v进队
while (front!=rear)         //若队列不空时循环
{
front=(front+1)%MAXV;
w=queue[front];             //出队并赋给w
p=G->adjlist[w].firstarc;   //找w的第一个的邻接点
while (p!=NULL)
{
if (visited[p->adjvex]==0)
{
printf("%2d",p->adjvex); //访问之
visited[p->adjvex]=1;
rear=(rear+1)%MAXV; //该顶点进队
queue[rear]=p->adjvex;
}
p=p->nextarc;       //找下一个邻接顶点
}
}
printf("\n");
}

int main()
{
ALGraph *G;
int A[5][5]=
{
{0,1,0,1,0},
{1,0,1,0,0},
{0,1,0,1,1},
{1,0,1,0,1},
{0,0,1,1,0}
};
ArrayToList(A[0], 5, G);

printf(" 由2开始广度遍历:");
BFS(G, 2);

printf(" 由0开始广度遍历:");
BFS(G, 0);
return 0;

输出结果：



学习心得：

对于广度优先遍历BFS首先是清楚BFS的算法过程：

（1）首先访问初始点a

（2）接着访问a的所有未被访问过的邻接点a1，a2，a3，……，an；按照a1，a2，a3，……，an的次序，访问每一个顶点的所有未被访问过的邻接点。

（3）直到图中所有和初始点a有路径相通的顶点都被访问过为止。

例如：



① 0 → 1 → 3 → 4 → 2

② 2 → 1 → 3 → 4 → 0

对于以上的例子（以0 → 1 → 3 → 4 → 2为例）

先访问顶点0，再访问与0相通的所有顶点，并按一定的顺序访问，也就是由上到下或者由左到右的顺序进行访问即：0 → 1 → 3 → 4，当访问完4之后，再由0所访问的第一个顶点开始，继续向下一个顶点访问，也就是与1相通的2.即最终结果：0 → 1 → 3 → 4 → 2。这其中所用到的是先进先出的队列的思想。

对于BFS实现:

        在遍历的时候,图的起始点是v,此时需要设置一个队列,int queue[MAXV],这是一个环形队列,将环形队列的队头和队尾都都设置成0,即front=0,rear=0.

        在进行访问之前,需要定义一个存放节点的访问标志的数组visited[MAXV]数组,首先哟将visit[]数组全置0.

       

    printf("%2d",v);            //输出被访问顶点的编号  

    visited[v]=1;                       //置已访问标记  

    rear=(rear+1)%MAXV;  

    queue[rear]=v;              //v进队  

        访问第一个顶点并入队,进行遍历,访问顶点v,并将visited[v]赋值为1,若以起始顶点为2做例,则,入队时,根据环形队列的入队,先要调节环形队列的位置针,将visited[]原先的0,变为1,并将环形队列queue[]中的1的位置赋值为2.则原先的queue[]环形队列的头节点为[0]尾节点为[1]

     while (p!=NULL)  

        {  

            if (visited[p->adjvex]==0)  

            {  

                printf("%2d",p->adjvex); //访问之  

                visited[p->adjvex]=1;  

                rear=(rear+1)%MAXV; //该顶点进队  

                queue[rear]=p->adjvex;  

            }  

            p=p->nextarc;       //找下一个邻接顶点  

        }  

        接下来需要判断,当队尾不为空的时候,需要取出队中顶点,访问未访问的邻接点并使之入队,则需要将queue[1]中的2取出,再将队头front指向queue[1]的位置,当2出队之后,发现2的邻接点为1.3.4,并分别对1.3.4进行访问,因此在visited[]数组中,依次将1.3.4由0变为1,并且对环形队列queue[]的[2].[3].[4]号位置,分别进入1.3.4,当队伍不空的时候,继续取出节点.接下来就是从[2]号位取出1.再进行1的邻接点的访问.依次下去即可得到最终的BFS广度遍历的结果.