C语言-数据结构无向图的广度优先遍历BFS（邻接矩阵存储）

Happy鱿鱼

已于 2024-08-24 00:17:44 修改

阅读量1k

点赞数 20

文章标签：深度优先 c语言数据结构

于 2024-08-22 17:31:12 首次发布

本文链接：https://blog.youkuaiyun.com/BamBoo_Bean/article/details/141405469

版权

在图的遍历中，广度优先是利用了队列进行操作，我们使用顺序队列，同时存储图的方式采用邻接矩阵，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] = GRAPH_INFINITY;
	G->arc[3][5] = GRAPH_INFINITY;
	G->arc[3][6] = GRAPH_INFINITY;
	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;
}

运行结果：