在图的遍历中,广度优先是利用了队列进行操作,我们使用顺序队列,同时存储图的方式采用邻接矩阵,BFS每次操作中当遍历到一个结点时先访问它,然后把它入队,之后在队列中加入这个结点的邻接结点,最后把队列中首元素出队。一直循环这个操作,直至所有结点都被访问。思想很简单,但实现的代码需要知道以下几个概念:
队列:先进后出,具体实现看我之前的顺序队列文章
邻接矩阵图的存储:
邻接矩阵是对称的
1表示有边,也可也用其他数值表示为权值
0表示无边
邻接矩阵对称赋值操作
未进行对称前:
进行对称操作后:
对应的邻接矩阵实现,我在代码里就简单暴力手动输入了这些数据,只输入了上三角的数据,下三角根据邻接矩阵对称的特点进行自动赋值
我们将创建这个图,它的广度优先搜索顺序是ABFCGEDH对吗?答案是对的
那如果修改邻接矩阵呢,不改变边的存储,还是这个ABFCGEDH顺序吗?答案就不一定了,也可以是ABFGCEHD等,为什么会这样,是因为邻接矩阵中每个结点存储的顺序问题,当邻接矩阵确定的时候并且开始访问的第一个结点确定,那么最后的顺序就是唯一的
我的结点存储顺序为ABCDEFGH,字母正好顺序的,如果你把字母换下位置也是可以的,对于边存储不影响,但是每一个结点访问邻接结点的时候,有影响这会导致优先访问的邻接结点不一样,所以我们一般就按照顺序来约定,否则考试答案也不唯一了!
虽然邻接矩阵的字母存储顺序不同,会导致最后的访问序列不唯一,但也是有规律的看下图,由于每个结点其邻接结点都在同一层,例如第二层我们有两种情况邻接矩阵存储的字母顺序,要么先B要么先F,不管先那一个,他们始终在同一层,所以在开始结点确定的情况下,最终A结点开头访问序列可能情况为:
A --->[BF]---> [[CG][E]]---> [[D][H]] 最内层[]括号里面元素可以任意间相互换位置红色标记部分,黑色框是由上一级的邻接结点决定,或者说由之前入队元素顺序决定 紫色框是层次不能直接相互换(根据开始结点确定紫色框顺序) 类似为广义表
层次示意图:
BFS核心代码:
完整代码(包括三大部分:顺序队列、邻接矩阵、BFS算法):
#include "stdio.h"
#include "stdlib.h"
#include "math.h"
#include "time.h"
// 禁用特定的警告
#pragma warning(disable:4996)
// 定义一些常量和数据类型
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXVEX 8 /* 最大顶点数,用户定义 */
#define QUEUEMAXSIZE 10
#define GRAPH_INFINITY 0 /* 用0表示∞,表示不存在边 */
/* 定义状态、顶点和边的类型 */
typedef int Status; /* Status是函数的返回类型,如OK表示成功 */
typedef char VertexType; /* 顶点的类型,用字符表示 */
typedef int EdgeType; /* 边上的权值类型,用整数表示 */
typedef int Boolean; /* 布尔类型 */
/* 访问标记数组 */
Boolean visited[MAXVEX];
/* 图的邻接矩阵结构体 */
typedef struct
{
VertexType vexs[MAXVEX]; /* 顶点表 */
EdgeType arc[MAXVEX][MAXVEX]; /* 邻接矩阵,表示边的权值 */
int numNodes, numEdges; /* 图中当前的顶点数和边数 */
} MGraph;
/* 创建一个无向网图的邻接矩阵表示 */
void CreateMGraph(MGraph* G)
{
int i, j, k, w;
// 初始化图的顶点数和边数
G->numNodes = 8;
G->numEdges = 12;
// 定义顶点标签
char Array[] = "ABCDEFGH";
// 初始化邻接矩阵和顶点表
for (i = 0; i < G->numNodes; i++) {
for (j = 0; j < G->numNodes; j++) {
G->arc[i][j] = GRAPH_INFINITY; /* 初始化邻接矩阵为∞ */
}
G->vexs[i] = Array[i]; /* 初始化顶点表 */
}
// 设置具体的边的权值
G->arc[0][0] = GRAPH_INFINITY;
G->arc[0][1] = 1;
G->arc[0][2] = GRAPH_INFINITY;
G->arc[0][3] = GRAPH_INFINITY;
G->arc[0][4] = GRAPH_INFINITY;
G->arc[0][5] = 1;
G->arc[0][6] = GRAPH_INFINITY;
G->arc[0][7] = GRAPH_INFINITY;
G->arc[1][0] = GRAPH_INFINITY;
G->arc[1][1] = GRAPH_INFINITY;
G->arc[1][2] = 1;
G->arc[1][3] = GRAPH_INFINITY;
G->arc[1][4] = GRAPH_INFINITY;
G->arc[1][5] = GRAPH_INFINITY;
G->arc[1][6] = 1;
G->arc[1][7] = GRAPH_INFINITY;
G->arc[2][0] = GRAPH_INFINITY;
G->arc[2][1] = GRAPH_INFINITY;
G->arc[2][2] = GRAPH_INFINITY;
G->arc[2][3] = 1;
G->arc[2][4] = GRAPH_INFINITY;
G->arc[2][5] = GRAPH_INFINITY;
G->arc[2][6] = GRAPH_INFINITY;
G->arc[2][7] = GRAPH_INFINITY;
G->arc[3][0] = GRAPH_INFINITY;
G->arc[3][1] = GRAPH_INFINITY;
G->arc[3][2] = GRAPH_INFINITY;
G->arc[3][3] = GRAPH_INFINITY;
G->arc[3][4] = 1;
G->arc[3][5] = GRAPH_INFINITY;
G->arc[3][6] = 1;
G->arc[3][7] = 1;
G->arc[4][0] = GRAPH_INFINITY;
G->arc[4][1] = GRAPH_INFINITY;
G->arc[4][2] = GRAPH_INFINITY;
G->arc[4][3] = GRAPH_INFINITY;
G->arc[4][4] = GRAPH_INFINITY;
G->arc[4][5] = 1;
G->arc[4][6] = GRAPH_INFINITY;
G->arc[4][7] = 1;
G->arc[5][0] = GRAPH_INFINITY;
G->arc[5][1] = GRAPH_INFINITY;
G->arc[5][2] = GRAPH_INFINITY;
G->arc[5][3] = GRAPH_INFINITY;
G->arc[5][4] = GRAPH_INFINITY;
G->arc[5][5] = GRAPH_INFINITY;
G->arc[5][6] = 1;
G->arc[5][7] = 0;
G->arc[6][0] = GRAPH_INFINITY;
G->arc[6][1] = GRAPH_INFINITY;
G->arc[6][2] = GRAPH_INFINITY;
G->arc[6][3] = GRAPH_INFINITY;
G->arc[6][4] = GRAPH_INFINITY;
G->arc[6][5] = GRAPH_INFINITY;
G->arc[6][6] = GRAPH_INFINITY;
G->arc[6][7] = 1;
G->arc[7][0] = GRAPH_INFINITY;
G->arc[7][1] = GRAPH_INFINITY;
G->arc[7][2] = GRAPH_INFINITY;
G->arc[7][3] = GRAPH_INFINITY;
G->arc[7][4] = GRAPH_INFINITY;
G->arc[7][5] = GRAPH_INFINITY;
G->arc[7][6] = GRAPH_INFINITY;
G->arc[7][7] = GRAPH_INFINITY;
// 由于是无向图,邻接矩阵是对称的,需要将其对称
for (int i = 0; i < G->numNodes; i++) {
for (int j = 0; j < G->numNodes; j++) {
G->arc[j][i] = G->arc[i][j];
}
}
// 打印邻接矩阵
printf("邻接矩阵为:\n ");
for (int i = 0; i < G->numNodes; i++) {
printf("%d ", i); /* 打印列索引 */
}
printf("\n ");
for (int i = 0; i < G->numNodes; i++) {
printf("%c ", G->vexs[i]); /* 打印顶点标签 */
}
printf("\n");
for (int i = 0; i < G->numNodes; i++) {
printf("%d ", i); /* 打印行索引 */
printf("%c ", G->vexs[i]); /* 打印顶点标签 */
for (int j = 0; j < G->numNodes; j++) {
if (G->arc[i][j] == 1) {
printf("\033[31m%d \033[0m", G->arc[i][j]); /* 打印邻接矩阵中的权值 */
}
else {
printf("%d ", G->arc[i][j]); /* 打印邻接矩阵中的权值 */
}
}
printf("\n");
}
}
// 定义顺序队列结构体
typedef struct {
int data[QUEUEMAXSIZE]; // 存储队列元素的数组
int front; // 队列的前端(队首)
int rear; // 队列的后端(队尾)
} SeqQueue;
// 初始化队列
void InitQueue(SeqQueue* q) {
q->front = 0; // 队列的前端初始化为0
q->rear = 0; // 队列的后端初始化为0
}
// 检查队列是否为空
int QueueIsEmpty(SeqQueue q) {
return q.front == q.rear;
}
// 检查队列是否已满
int IsFull(SeqQueue* q) {
return (q->rear + 1) % QUEUEMAXSIZE == q->front;
}
// 入队操作
int Enqueue(SeqQueue* q, int index) {
if (IsFull(q)) {
printf("Queue is full!\n");
return -1; // 入队失败
}
q->data[q->rear] = index; // 将元素放入队尾
q->rear = (q->rear + 1) % QUEUEMAXSIZE; // 更新队尾指针
return 0; // 入队成功
}
// 出队操作
int Dequeue(SeqQueue* q, int* item) {
if (QueueIsEmpty(*q)) {
printf("Queue is empty!\n");
return -1; // 出队失败
}
*item = q->data[q->front]; // 从队首获取元素
q->front = (q->front + 1) % QUEUEMAXSIZE; // 更新队首指针
return 0; // 出队成功
}
// 打印队列中的所有元素
void PrintQueue(SeqQueue q) {
if (QueueIsEmpty(q)) {
printf("Queue is empty!\n");
return;
}
int i = q.front;
while (i != q.rear) {
printf("%c ", q.data[i]);
i = (i + 1) % QUEUEMAXSIZE;
}
printf("\n");
}
void BFSTraverse(MGraph G) {
int i, j; // 遍历节点和邻接节点的索引
SeqQueue Q; // 队列用于存储待访问的节点
InitQueue(&Q); // 初始化队列
// 初始化所有节点的访问标记为 FALSE(未访问)
for (i = 0; i < G.numNodes; i++) {
visited[i] = FALSE;
}
// 遍历所有节点
printf("\n广度优先搜索(BFS)的结果为:");
for (i = 0; i < G.numNodes; i++) {
// 如果节点 i 未被访问过
if (!visited[i]) {
visited[i] = TRUE; // 标记节点 i 为已访问
Enqueue(&Q, i); // 将节点 i 入队
printf("%c->", G.vexs[i]); // 打印节点 i 的值
// 当队列不为空时,继续遍历
while (!QueueIsEmpty(Q)) {
Dequeue(&Q, &i); // 出队一个节点 i
// 遍历节点 i 的所有邻接节点
for (j = 0; j < G.numNodes; j++) {
// 如果节点 i 和 j 之间有边且节点 j 未被访问过
if (G.arc[i][j] == 1 && !visited[j]) {
visited[j] = TRUE; // 标记节点 j 为已访问
printf("%c->", G.vexs[j]); // 打印节点 j 的值
Enqueue(&Q, j); // 将节点 j 入队
}
}
}
}
}
printf("\n");
}
int main(void)
{
MGraph G;
/* 创建图 */
CreateMGraph(&G);
/* 深度优先遍历图 */
BFSTraverse(G);
return 0;
}
运行结果: