标签：vexNum return LNode int 邻接矩阵 C语言 edge visited 考研

图的结构如下：

图的邻接矩阵实现 + 广度(BFS)、深度(DFS)优先遍历：

#include<stdio.h>
#include<stdlib.h>

#define MAXVEXNUM 10

// 定义图的邻接矩阵存储结构
struct MGraph{

	int vex[MAXVEXNUM]; // 顶点集
	int edge[MAXVEXNUM][MAXVEXNUM]; // 边集
	int vexNum, arcNum;
};

// 初始化邻接矩阵
void initMGraph(MGraph& G) {

	for(int i = 0;i < 8;i++) {
	
		G.vex[i] = i + 1;
	}

	G.vexNum = 8;

	for(int i = 0;i < G.vexNum;i++) {
	
		for(int j = 0;j < G.vexNum;j++) {
		
			G.edge[i][j] = 0;
		}
	}

	G.edge[0][1] = G.edge[0][4] = 1;
	G.edge[1][0] = G.edge[1][5] = 1;
	G.edge[2][3] = G.edge[2][5] = G.edge[2][6] = 1;
	G.edge[3][2] = G.edge[3][6] = G.edge[3][7] = 1;
	G.edge[4][0] = 1;
	G.edge[5][1] = G.edge[5][2] = G.edge[5][6] = 1;
	G.edge[6][2] = G.edge[6][3] = G.edge[6][5] = G.edge[6][7] = 1;
	G.edge[7][3] = G.edge[7][6] = 1;

	G.arcNum = 10;
}

// 广度优先遍历

// ①定义队列数据结构
// 定义结点数据类型
typedef struct LNode {

	int data;
	struct LNode *next;
}LNode;

// 定义链队数据类型
typedef struct {

	LNode *front, *rear;
}LiQueue;

void initLiQueue(LiQueue &Q) {

	Q.front = Q.rear = (LNode *)malloc(sizeof(LNode));
	Q.front->next = NULL;
}

// 判断队列空
bool isEmpty(LiQueue Q) {

	if(Q.front == Q.rear)
		return true;

	return false;
}

// 入队操作
void enQueue(LiQueue &Q, int e) {

	LNode *p = (LNode *)malloc(sizeof(LNode));

	p->data = e;

	p->next = NULL;

	Q.rear->next = p;

	Q.rear = p;
}

// 出队操作
bool deQueue(LiQueue &Q, int &e) {

	if(isEmpty(Q))
		return false;

	LNode *p = Q.front->next;

	e = p->data;

	Q.front->next = p->next;

	// 如果出队元素是队列的最后一个元素,需要修改尾指针
	if(p == Q.rear)
		Q.rear = Q.front;

	free(p);

	return true;
}

// 定义访问数组，标记已访问顶点
bool visited[MAXVEXNUM];

// 获取顶点v的相邻顶点
int getFirstNeighbor(MGraph G, int v) {

	for(int i = 0;i < G.vexNum;i++) {
	
		if(G.edge[v - 1][i] != 0) // v-1因为数组是从0开始的，而顶点从1开始
			return i + 1;
	}

	return -1;// -1表示没有相邻顶点
}

// 获取顶点v除顶点u之外的相邻顶点
int getNextNeighbor(MGraph G, int v, int u) {

	for(int i = u;i < G.vexNum;i++) {
	
		if(G.edge[v - 1][i] != 0)
			return i + 1;
	}

	return -1;
}

void BFS(MGraph G, int v, LiQueue &Q) {

	printf("广度优先遍历顶点:%d\n", v);
	visited[v - 1] = true;
	enQueue(Q, v);

	while(!isEmpty(Q)) {
	
		deQueue(Q, v);
		for(int w = getFirstNeighbor(G, v);w >= 1;w = getNextNeighbor(G, v, w)) {
		
			if(!visited[w - 1]) {
			
				printf("广度优先遍历顶点:%d\n", w);
				visited[w - 1] = true;
				enQueue(Q, w);
			}
		}
	}
}

void BFSTraverse(MGraph G) {

	for(int i = 0;i < G.vexNum;i++) {
	
		visited[i] = false;
	}

	LiQueue Q;
	initLiQueue(Q);

	for(int i = 0;i < G.vexNum;i++) {
	
		if(!visited[i])
			BFS(G, G.vex[i], Q);
	}
}

// 深度优先遍历
void DFS(MGraph G, int v) {

	printf("深度优先遍历顶点:%d\n", v);
	visited[v - 1] = true;

	for(int w = getFirstNeighbor(G, v);w >= 1;w = getNextNeighbor(G, v, w)) {
	
		if(!visited[w - 1]) {
		
			DFS(G, w);
		}
	}
}

void DFSTravse(MGraph G) {

	for(int i = 0;i < G.vexNum;i++) {
	
		visited[i] = false;
	}

	for(int i = 0;i < G.vexNum;i++) {
	
		if(!visited[i])
			DFS(G, G.vex[i]);
	}
}

int main(void) {

	MGraph G;
	initMGraph(G);

	BFSTraverse(G);

	printf("\n");

	DFSTravse(G);
	system("pause");
	return 0;
}

标签：vexNum,return,LNode,int,邻接矩阵,C语言,edge,visited,考研
来源： https://www.cnblogs.com/dqlai/p/16345142.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。