图用邻接矩阵实现，深度优先遍历和广度优先遍历

于 2023-06-03 17:47:35 发布
阅读量2.8k 收藏 47
点赞数 10
文章标签： 深度优先 宽度优先 算法 c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_73805125/article/details/131023236
版权

邻接矩阵的结构体

#define MAXVertexNum 20//顶点数目最大值
typedef char Vertextype;//顶点的数据类型
typedef int Edgetype;//带权图中边上权值的数据类型
typedef struct
{
	Vertextype Vertex[MAXVertexNum];//顶点表
	Edgetype Edge[MAXVertexNum][MAXVertexNum];//邻接矩阵，边表
	int vernum, arcnum; //图的顶点数和弧数
}MGraph;

邻接矩阵图的建立

        图的建立有多种实现方式，我这里是从键盘输入顶点数，边条数，并从键盘输入边的关系

图是带有权值的，并且把环的权值赋值为0，两个顶点没有边权值为32767。

void CreateMGraph(MGraph *G)//图的建立
{
	char cls;//用于清除缓冲区的回车
	int i, j, w, k;
	printf("请输入顶点的数量\n");
	scanf_s("%d", &(G->vernum));
	cls = getchar();//清除缓冲区回车
	printf("请输入边的条数\n");
	scanf_s("%d", &(G->arcnum));
	cls = getchar();
	printf("请输入顶点信息\n");
	for (i = 0; i < G->vernum; i++)//给存储顶点数组赋值
	{
		scanf_s("%c", &(G->Vertex[i]), 1);
	}
	cls = getchar();//清除缓冲区回车
	for (i = 0; i < G->vernum; i++)//初始化边的关系
	{
		for (j = 0; j < G->vernum; j++)
		{
			if (j == i)
			{
				G->Edge[i][j] = 0;//这里我把指向自己的边权值赋值为0
			}
			else
			{
				G->Edge[i][j] = 32767;//指向别人的边赋值为32767
			}
		}
	}
	for (k = 0; k < G->arcnum; k++)//给边赋值
	{
		printf("请输入边的起点序号，终点序号，权值(用空格隔开)：");
		scanf_s("%d%d%d", &i, &j, &w);
		cls = getchar();
		G->Edge[i - 1][j - 1] = w;
		G->Edge[j - 1][i - 1] = w;//无向图具有对称性
	}
}

查找顶点v，并且返回v的相关信息

        通过循环去找顶点，如果找到了打印出顶点的位置（节点数组的第几个），并找出与之相连的边，找到了打印出与哪条边相关联，如果想知道权值也可加入

printf("权值为：%d\n",G->Edge[i][j]);

void GetVex(MGraph* G, Vertextype v)//找到顶点v并返回v的相关信息
{
	int i, j;
	for (i = 0; i < G->vernum; i++)
	{
		if (v == G->Vertex[i])
		{
			break;//v存在的话就退出
		}
	}
	if (i == G->vernum)//判断v是否存在
	{
		printf("没找到:%c\n", v);
		return;
	}
	else
	{
		printf("顶点在第：%d个位置\n", i + 1);//打印v在的位置
		for (j = 0; j < G->vernum; j++)
		{
			if (G->Edge[i][j] != 0 && G->Edge[j][i] != 32767)//打印和v存在边关系的vertex[j]
			{
				printf("%c和%c存在边\n", G->Vertex[i], G->Vertex[j]);//打印和v相连的边
			}
		}
	}
}

替换顶点 

        如你所见代码是将某个顶点替换成某个顶点

void PutVex(MGraph* G, Vertextype v ,Vertextype value)//替换顶点，将v换成value
{
	int i;
	for (i = 0; i < G->vernum; i++)//去边集里面找v
	{
		if (v == G->Vertex[i])
		{
			G->Vertex[i] = value;
			printf("将%c替换%c成功", v, value);
			return;
		}
	}
	if (i == G->vernum)
	{
		printf("没找到:%c\n",v);
	}
}

新增顶点

         如你所见代码是在图中新增一个顶点

void InsertVex(MGraph* G, Vertextype v)//新增顶点v
{
	if (G->vernum == MAXVertexNum)
	{
		printf("图满了，存不下了\n");
		return;
	}
	int i, j;
	G->Vertex[G->vernum] = v;
	G->vernum++;
	//初始化和顶点的边
	G->Edge[G->vernum - 1][G->vernum - 1] = 0;
	for (i = 0; i < G->vernum - 1; i++)
	{
		G->Edge[i][G->vernum - 1] = 32767;
		G->Edge[G->vernum - 1][i] = 32767;
	}
	//输入边,G->arcnum（边的数量）要++
	printf("请输入想要与顶点新增的边的序号和权值(输入-1和-1结束)\n");
	while (1)
	{
		scanf_s("%d%d", &j, &i);//用j来表示与之相连的顶点存储位置（下标=位置-1）i来存储权值
		if (j == -1 && i == -1)break; 
		else if (j<1 || j>G->vernum)
		{
			printf("输入错误，请重新输入\n");
			continue;
		}
		G->Edge[G->vernum - 1][j-1] = i;//确定边的关系
		G->Edge[j - 1][G->vernum - 1] = i;
		G->arcnum++;
	}
}

打印矩阵的边的权值

        将所有的权值打印出来，直观的表示

void PrintMGraph(MGraph* G)//打印矩阵
{
	int i, j;
	printf("图的矩阵表示为:\n");
	for (i = 0; i < G->vernum; i++)
	{
		for (j = 0; j < G->vernum; j++)
		{
			printf("%d\t", G->Edge[i][j]);//第i行第j列
		}
		printf("\n");
	}
}

深度优先遍历

        认真听，认真听，重头戏来了

深度优先遍历，我先用一个visited数组用来保存节点是否被访问，具体代码如下：

/*
深度优先搜索,遍历算法
*/
int visited[MAXVertexNum] = { 0 };//用于记录数组节点是否被访问，访问了就变为1
void DFS(MGraph* G, int i)
{
	visited[i] = 1;//访问过的顶点标记为1
	printf("%c ", G->Vertex[i]);//在进行遍历之前打印访问的顶点
	for (int j = 0; j < G->vernum; j++)//从第0个顶点开始判断，直到最后一个顶点
	{
		if (!visited[j] && G->Edge[i][j] == 1)//若顶点vexs[j]与顶点vexs[i]相连，并且vexs[j]没有访问过
		{
			DFS(G, j);//那就访问vexs[j]
		}
	}
	//printf("%c ", G->Vertex[i]);//如果写在最后，则逆序输出，可以将上面的cout注释掉试一下
}
void DFSTraverseAL(MGraph *G)
{
	for (int i = 0; i < G->vernum; i++) //从vexs[0]开始进行深度优先递归，若是连通图，只会执行一次DFS(G,0)
	{
		if (!visited[i])//判断是否已被访问
		{
			DFS(G, i);
		}
	}
	/*
    //因为深度优先递归后每个visited[i]都是1，不会再执行if了
     //若是非连通图，可能会执行到DFS(G,1)，DFS(G,2)，DFS(G,3)，DFS(G,4)*/
}

广度优先遍历

        由于上面没有涉及到队，但是不代表不会用到，在广度优先遍历中，我用队来实现遍历。

因为队这种数据结构，后进后出，很好的切合了广度优先遍历（也就是层次遍历），所以定义了队，话不多说请看代码：

typedef struct LQueueNode//队节点
{
	int data;//队的数据类型
	struct LQueueNode* next;
}LQueueNode;
typedef struct LQueue//队
{
	LQueueNode* front;//队的头指针
	LQueueNode* rear;//尾指针
}LQueue;
void InitLQueue(LQueue* Q)//队的初始化
{
	LQueueNode* p = (LQueueNode*)malloc(sizeof(LQueueNode));
	if (p == NULL)
		exit(-1);
	p->next = NULL;
	Q->front = p;
	Q->rear = p;
}
void PushLQueue(LQueue* Q,int x)//入队操作
{
	LQueueNode* p = (LQueueNode*)malloc(sizeof(LQueueNode));
	if (p == NULL)
		exit(-1);
	p->data = x;
	p->next = NULL;
	Q->rear->next = p;
	Q->rear = p;
}
int PopLQueue(LQueue* Q)//出队操作
{
	if (Q->front->next == NULL)
	{
		printf("队为空\n");
		return -1;
	}
	else
	{
		LQueueNode* r = Q->front->next;
		if (Q->front->next->next == NULL)//如果只有一个元素的话，头删会使得尾指针丢失变为野指针
		{
			Q->rear = Q->front;
		}
		int n = r->data;
		Q->front->next = Q->front->next->next;
		free(r);
		r = NULL;
		return n;
	}
}
int LQueueEmpty(LQueue* Q)//判断队列是否为空
{
	if (Q->front->next == NULL)
		return 0;//空为0
	else
		return 1;//非空为1
}

 相信大家已经队这种数据结构已经掌握了，这里就不细说了，请看重头戏：

void BFSraverseAL(MGraph* G)
{
	int i, j;
	for (i = 0; i < G->vernum; i++)//初始化保存标志位的信息
		visited[i] = 0;
	LQueue Q;
	InitLQueue(&Q);
	for (i = 0; i < G->vernum; i++)
	{							   
		if (!visited[i])//未访问过 该顶点
		{
			visited[i] = 1;
			printf("%c ", G->Vertex[i]);
			PushLQueue(&Q, i);
			while (LQueueEmpty(&Q))
			{
				i = PopLQueue(&Q); //将队中元素出队列，赋值给i
				for (j = 0; j < G->vernum; j++)
				{
					if (!visited[j] && G->Edge[i][j])//其他顶点与该顶点存在边
					{
						visited[j] = 1;
						printf("%c ", G->Vertex[j]);
						PushLQueue(&Q, j);
					}
				}
			}
		}
	}
}

完整代码如下：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#pragma warning(disable:6386)//忽略6386错误,（这里我使用的编译器是vs2019不清楚为什么会有6386报错）
#define MAXVertexNum 20//顶点数目最大值
typedef char Vertextype;//顶点的数据类型
typedef int Edgetype;//带权图中边上权值的数据类型
typedef struct
{
	Vertextype Vertex[MAXVertexNum];//顶点表
	Edgetype Edge[MAXVertexNum][MAXVertexNum];//邻接矩阵，边表
	int vernum, arcnum; //图的顶点数和弧数
}MGraph;
typedef struct LQueueNode//队节点
{
	int data;//队的数据类型
	struct LQueueNode* next;
}LQueueNode;
typedef struct LQueue//队
{
	LQueueNode* front;//队的头指针
	LQueueNode* rear;//尾指针
}LQueue;
void CreateMGraph(MGraph *G)//图的建立
{
	char cls;//用于清除缓冲区的回车
	int i, j, w, k;
	printf("请输入顶点的数量\n");
	scanf_s("%d", &(G->vernum));
	cls = getchar();//清除缓冲区回车
	printf("请输入边的条数\n");
	scanf_s("%d", &(G->arcnum));
	cls = getchar();
	printf("请输入顶点信息\n");
	for (i = 0; i < G->vernum; i++)//给存储顶点数组赋值
	{
		scanf_s("%c", &(G->Vertex[i]), 1);
	}
	cls = getchar();//清除缓冲区回车
	for (i = 0; i < G->vernum; i++)//初始化边的关系
	{
		for (j = 0; j < G->vernum; j++)
		{
			if (j == i)
			{
				G->Edge[i][j] = 0;//这里我把指向自己的边权值赋值为0
			}
			else
			{
				G->Edge[i][j] = 32767;//指向别人的边赋值为32767
			}
		}
	}
	for (k = 0; k < G->arcnum; k++)//给边赋值
	{
		printf("请输入边的起点序号，终点序号，权值(用空格隔开)：");
		scanf_s("%d%d%d", &i, &j, &w);
		cls = getchar();
		G->Edge[i - 1][j - 1] = w;
		G->Edge[j - 1][i - 1] = w;//无向图具有对称性
	}
}
void GetVex(MGraph* G, Vertextype v)//找到顶点v并返回v的相关信息
{
	int i, j;
	for (i = 0; i < G->vernum; i++)
	{
		if (v == G->Vertex[i])
		{
			break;//v存在的话就退出
		}
	}
	if (i == G->vernum)//判断v是否存在
	{
		printf("没找到:%c\n", v);
		return;
	}
	else
	{
		printf("顶点在第：%d个位置\n", i + 1);//打印v在的位置
		for (j = 0; j < G->vernum; j++)
		{
			if (G->Edge[i][j] != 0 && G->Edge[j][i] != 32767)//打印和v存在边关系的vertex[j]
			{
				printf("%c和%c存在边\n", G->Vertex[i], G->Vertex[j]);//打印和v相连的边
			}
		}
	}
}

void PutVex(MGraph* G, Vertextype v ,Vertextype value)//替换顶点，将v换成value
{
	int i;
	for (i = 0; i < G->vernum; i++)//去边集里面找v
	{
		if (v == G->Vertex[i])
		{
			G->Vertex[i] = value;
			printf("将%c替换%c成功", v, value);
			return;
		}
	}
	if (i == G->vernum)
	{
		printf("没找到:%c\n",v);
	}
}

void InsertVex(MGraph* G, Vertextype v)//新增顶点v
{
	if (G->vernum == MAXVertexNum)
	{
		printf("图满了，存不下了\n");
		return;
	}
	int i, j;
	G->Vertex[G->vernum] = v;
	G->vernum++;
	//初始化和顶点的边
	G->Edge[G->vernum - 1][G->vernum - 1] = 0;
	for (i = 0; i < G->vernum - 1; i++)
	{
		G->Edge[i][G->vernum - 1] = 32767;
		G->Edge[G->vernum - 1][i] = 32767;
	}
	//输入边,G->arcnum（边的数量）要++
	printf("请输入想要与顶点新增的边的序号和权值(输入-1和-1结束)\n");
	while (1)
	{
		scanf_s("%d%d", &j, &i);//用j来表示与之相连的顶点存储位置（下标=位置-1）i来存储权值
		if (j == -1 && i == -1)break; 
		else if (j<1 || j>G->vernum)
		{
			printf("输入错误，请重新输入\n");
			continue;
		}
		G->Edge[G->vernum - 1][j-1] = i;//确定边的关系
		G->Edge[j - 1][G->vernum - 1] = i;
		G->arcnum++;
	}
}
void PrintMGraph(MGraph* G)//打印矩阵
{
	int i, j;
	printf("图的矩阵表示为:\n");
	for (i = 0; i < G->vernum; i++)
	{
		for (j = 0; j < G->vernum; j++)
		{
			printf("%d\t", G->Edge[i][j]);//第i行第j列
		}
		printf("\n");
	}
}
/*
深度优先搜索,遍历算法
*/
int visited[MAXVertexNum] = { 0 };//用于记录数组节点是否被访问，访问了就变为1
void DFS(MGraph* G, int i)
{
	visited[i] = 1;//访问过的顶点标记为1
	printf("%c ", G->Vertex[i]);//在进行遍历之前打印访问的顶点
	for (int j = 0; j < G->vernum; j++)//从第0个顶点开始判断，直到最后一个顶点
	{
		if (!visited[j] && G->Edge[i][j] == 1)//若顶点vexs[j]与顶点vexs[i]相连，并且vexs[j]没有访问过
		{
			DFS(G, j);//那就访问vexs[j]
		}
	}
	//printf("%c ", G->Vertex[i]);//如果写在最后，则逆序输出，可以将上面的cout注释掉试一下
}
void DFSTraverseAL(MGraph *G)
{
	for (int i = 0; i < G->vernum; i++) //从vexs[0]开始进行深度优先递归，若是连通图，只会执行一次DFS(G,0)
	{
		if (!visited[i])//判断是否已被访问
		{
			DFS(G, i);
		}
	}
	/*
    //因为深度优先递归后每个visited[i]都是1，不会再执行if了
     //若是非连通图，可能会执行到DFS(G,1)，DFS(G,2)，DFS(G,3)，DFS(G,4)*/
}
void InitLQueue(LQueue* Q)//队的初始化
{
	LQueueNode* p = (LQueueNode*)malloc(sizeof(LQueueNode));
	if (p == NULL)
		exit(-1);
	p->next = NULL;
	Q->front = p;
	Q->rear = p;
}
void PushLQueue(LQueue* Q,int x)//入队操作
{
	LQueueNode* p = (LQueueNode*)malloc(sizeof(LQueueNode));
	if (p == NULL)
		exit(-1);
	p->data = x;
	p->next = NULL;
	Q->rear->next = p;
	Q->rear = p;
}
int PopLQueue(LQueue* Q)//出队操作
{
	if (Q->front->next == NULL)
	{
		printf("队为空\n");
		return -1;
	}
	else
	{
		LQueueNode* r = Q->front->next;
		if (Q->front->next->next == NULL)//如果只有一个元素的话，头删会使得尾指针丢失变为野指针
		{
			Q->rear = Q->front;
		}
		int n = r->data;
		Q->front->next = Q->front->next->next;
		free(r);
		r = NULL;
		return n;
	}
}
int LQueueEmpty(LQueue* Q)//判断队列是否为空
{
	if (Q->front->next == NULL)
		return 0;//空为0
	else
		return 1;//非空为1
}

void BFSraverseAL(MGraph* G)
{
	int i, j;
	for (i = 0; i < G->vernum; i++)//初始化保存标志位的信息
		visited[i] = 0;
	LQueue Q;
	InitLQueue(&Q);
	for (i = 0; i < G->vernum; i++)
	{							  
		if (!visited[i])//未访问过 该顶点
		{
			visited[i] = 1;
			printf("%c ", G->Vertex[i]);
			PushLQueue(&Q, i);
			while (LQueueEmpty(&Q))
			{
				i = PopLQueue(&Q); //将队中元素出队列，赋值给i
				for (j = 0; j < G->vernum; j++)
				{
					if (!visited[j] && G->Edge[i][j])//其他顶点与该顶点存在边
					{
						visited[j] = 1;
						printf("%c ", G->Vertex[j]);
						PushLQueue(&Q, j);
					}
				}
			}
		}
	}
}
/*//一组数据
4
4
ABCD
1 2 1
1 3 1
2 3 1
3 4 1


*/
int main()
{
	MGraph G;
	CreateMGraph(&G);//图的建立
	//GetVex(&G, 'A'); //找到顶点A并返回A的相关信息
	//PutVex(&G, 'A', 'a');//替换顶点，将A换成a
	//InsertVex(&G, 'D');//新增顶点函数
	DFSTraverseAL(&G);
	printf("\n");
	BFSraverseAL(&G);
	printf("\n");
	PrintMGraph(&G);//矩阵的打印
	return 0;
}

恋上风
关注
  • 10
    点赞
  • 踩
  • 47
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
图的邻接矩阵以及深度优先遍历 + 广度优先遍历
JabamiYu的博客
01-25 3万+
图的邻接矩阵表示法非常简单，一个定点数组，一个二维数组搞定，类似与这样 下面简单实现一个邻接矩阵表示的方法的图，以及遍历的两种方式。 Graph.h #pragma once #define MAX_SIZE 30 templateclass T,class E> class Graph { public: Graph(size_t size); virtual ~
邻接矩阵和图的深度优先遍历
芳芳呀的博客
10-01 1565
#include<stdio.h> #include<iostream.h> #define MaxInt 32767 #define MVNum 100 #define OK 1 typedef char VerTexType; typedef int ArcType; typedef int Status; typedef struct { Ver...
邻接表或者邻接矩阵为存储结构实现连通无向图的深度优先和广度优先遍历
12-06
程序设计任务： 设计一个程序，实现以邻接表或者邻接矩阵为存储结构，实现连通无向图的深度优先和广度优先遍历。基本要求：以邻接表或者邻接矩阵为存储结构，实现连通无向图的深度优先和广度优先遍历。以用户指定的结点为起点，分别输出每种遍历下的结点访问序列和相应生成树的边集。测试数据：教科书p168图7.13(a)。
数据结构—图之邻接表
Gloria971111的博客
11-18 1045
尾插法建立邻接表，效率没有前插法高，但是可以去重#include<iostream> using namespace std; #include<string.h> #define MVNum 100typedef struct ArcNode { int adjvex;//该边所指向的顶点的位置 ArcNode *nextarc;//指向下一条边的指针 int info
深度优先遍历
xlh006的博客
09-05 7058
1、深度优先搜索遍历过程 图的深度优先搜索(Depth First Search)，和树的先序遍历比较类似。 它的思想：假设初始状态是图中所有顶点均未被访问，则从某个顶点v出发，首先访问该顶点，然后依次从它的各个未被访问的邻接点出发深度优先搜索遍历图，直至图中所有和v有路径相通的顶点都被访问到。 若此时尚有其他顶点未被访问到，则另选一个未被访问的顶点作起始点，重复上述过程，直至图中所有顶点都被...
autojs遍历当前页面所有控件_数据结构与算法： 三十张图弄懂「图的两种遍历方式」...
weixin_39667041的博客
11-18 1288
1 引言遍历是指从某个节点出发，按照一定的的搜索路线，依次访问对数据结构中的全部节点，且每个节点仅访问一次。 在二叉树基础中，介绍了对于树的遍历。树的遍历是指从根节点出发，按照一定的访问规则，依次访问树的每个节点信息。树的遍历过程，根据访问规则的不同主要分为四种遍历方式： (1)先序遍历 (2)中序遍历 (3)后序遍历 (4)层次遍历 类似的，图的遍历是指，从给定图中任意指定的顶点(称为初始点)出...
图的邻接矩阵表示，深度优先遍历，广度优先遍历实现
03-13
C++实现，数据结构，图的邻接矩阵表示，深度优先遍历，广度优先遍历，DFS，BFS，为什么要五十个字才能上传啊
数据结构—无向图创建邻接矩阵、深度优先遍历和广度优先遍历（C语言版）
热门推荐
正弦定理的博客
12-19 4万+
无向图创建邻接矩阵、深度优先遍历和广度优先遍历一、概念解析：（1）无向图：（2）邻接矩阵：二、创建邻接矩阵：三、深度遍历、广度遍历（1）深度遍历概念：（2）广度遍历概念：四、实例展示 一、概念解析： （1）无向图： 假设图G由两个集合V和E组成，记为G={V , E}。其中V是顶点的有限集合，E是连接V中两个不同顶点的边的有限集合。如果E中的顶点对是有序的，即E中的每条边都是有方向的，则称G是有向图。如果顶点对是无序的，则称G是无向图 （2）邻接矩阵： 邻接矩阵主要由：二维数组 实现 如图 转
C++构造无向图，邻接矩阵，深度优先遍历，广度优先遍历
qq_44757691的博客
12-14 6082
define MVNum 100 //最大顶点数//定义无向图邻接矩阵{//顶点表//邻接矩阵//图的当前定点数和边数};
建立图的邻接矩阵或邻接表存储并在此基础上实现图的深度优先遍历和广度优先遍历.doc
10-10
"建立图的邻接矩阵或邻接表存储并在此基础上实现图的深度优先遍历和广度优先遍历" 本文档主要介绍了图的存储方式，包括邻接矩阵和邻接表两种存储方法，并在此基础上实现了图的深度优先遍历和广度优先遍历。 一、图...
数据结构图的邻接矩阵,邻接表存储表示，图的深度优先搜索遍历，广度优先搜索遍历
06-17
数据结构图的邻接矩阵,邻接表存储表示，图的深度优先搜索遍历，广度优先搜索遍历 数据结构图的邻接矩阵,邻接表存储表示，图的深度优先搜索遍历，广度优先搜索遍历.rar
图的遍历之 深度优先搜索和广度优先搜索
xiedeacc的专栏
06-01 2921
出自：http://www.cnblogs.com/skywang12345/p/3711483.html 图的遍历之 深度优先搜索和广度优先搜索 本章会先对图的深度优先搜索和广度优先搜索进行介绍，然后再给出C/C++/Java的实现。 目录  1. 深度优先搜索的图文介绍  1.1 深度优先搜索介绍  1.2 深度优先搜索图解  2. 广度优先搜索的图文介绍 
分别用邻接矩阵和邻接表实现图的深度优先遍历和广度优先遍历_从零开始学习数据结构>图的遍历...
weixin_39812577的博客
11-21 1400
图的存储结构：邻接矩阵、邻接表，那么对于不同的存储结构必然存在着不同的访问方式，拿到具体数据的过程就是图的遍历。1、遍历图的遍历与树的很相似，遍历满足：(1)、对每一个顶点都得进行一次访问；(2)、对其不能进行重复的访问，只能是一次；对上次的一个补充: 当父类是模板类时，子类继承后，要是想调用父类的方法/数据，必须加上模板的作用域限定符，例 : Grapth::maxVertices;方...
暑假训练总结
sdau20163940的博客
08-25 287
转眼之间，暑假一个月的时间就飞逝了。其实回过头来，你会发现时间过得真的很快，时间是抓不住的，关键是你如何利用时间，使有限的时间发挥最大的效率，提高时间的利用率。回过头，总结一下一个暑假的工作成果，其实也是一种收获。 首先，一进入假期我们就把精力投入到了DP上面，DP在ACM中非常重要的，同时又是竞赛中的难点，因为该算法时间效率高，代码量少，多元性很强，主要考察自己的思维能力和建模的抽象能力以及自
图的邻接矩阵实现
dianlu7964的博客
05-23 695
用邻接矩阵存放图中顶点的关系，实现无向图的邻接矩阵存储。1）图的建立，删除（添加，删除边/顶点）2）广度和深度优先遍历3）prim最小生成树1，成员变量，构造函数，以及数组扩展实现策略：维护一个顶点的数组，以及一个二维的数组来表示顶点之间的关系，维护2个基本变量记录顶点和边的数量。重点是：1）可以动态扩展顶点数组，并保持数组的连续性，这意味着删除顶点时后面的顶点要前移，那么顶点的编号也变...
邻接矩阵深度优先和广度优先遍历（DFS和BFS）
花开不败
07-06 1万+
/*邻接矩阵的广度遍历算法*/ #include "stdio.h" #include "stdlib.h" #define OK 1 #define ERROR 1 #define FALSE 0 #define TRUE 1 typedef int Status; //Status是函数的类型，其值是函数结果状态代码 typedef int Boolean;//Boolean是布尔类型，其
图的广度优先遍历_邻接矩阵存储图的深度优先遍历
weixin_39753260的博客
12-05 231
试实现邻接矩阵存储图的深度优先遍历。输入样例：给定图如下5输出样例：DFS from 5: 5 1 3 0 2 4 6#include <stdio.h> typedef enum {false, true} bool; #define MaxVertexNum 10 /* 最大顶点数设为10 */ #define INFINITY 65535 /* ∞设为双字节无符号整数的...
c++实现邻接表实现的图，以及深度优先搜索，和广度优先搜索
weixin_41874599的博客
07-02 959
#include <iostream> #include <string> #include <stack> #include <queue> //深度优先 (使用栈，先进后出，后进先出) //广度优先（使用队列，先进先出，后进后出） #define max_verts 10 using namespace std; //邻接矩阵构建图 c...
利用邻接矩阵进行的深度优先和广度优先遍历（含全部代码+图解）
Initial_Mind的博客
04-29 4万+
良苦用心
邻接矩阵的深度优先遍历和广度优先遍历
最新发布
06-28
### 回答1： 邻接矩阵的深度优先遍历和广度优先遍历是图的两种遍历方式。 深度优先遍历是从起点开始，沿着一条路径一直走到底，直到不能再走为止，然后返回上一个节点，继续走其他路径，直到所有节点都被访问过为止。在邻接矩阵中，可以使用递归或栈来实现深度优先遍历。 广度优先遍历是从起点开始，先访问起点的所有邻居节点，然后依次访问它们的邻居节点，直到所有节点都被访问过为止。在邻接矩阵中，可以使用队列来实现广度优先遍历。 ### 回答2： 邻接矩阵是图的一种常见表示方法，其中通过二维数组来表示图的节点之间的关系。在邻接矩阵中，每个节点（或者说顶点）的行代表其所在的节点，而列则代表其与其他节点之间是否存在连边。如果该节点与另一个节点存在连边，则邻接矩阵中该行、该列的交叉处值为1，反之，如果不存在连边，则该交叉处值为0。基于邻接矩阵，我们可以进行深度优先遍历和广度优先遍历。 深度优先遍历（DFS）是一种对图进行遍历的方式，遵循“先访问子节点再访问兄弟节点”的原则。具体来说，该算法从某个节点开始遍历，访问其第一个未访问的子节点，对该子节点执行DFS遍历，直到到达某个叶子节点为止。然后回溯，访问该节点的下一个未访问的子节点，继续执行DFS遍历，直到所有子节点都被遍历完毕。DFS遍历过的节点，会在遍历结束后形成一个连通块。对于邻接矩阵，我们可以通过递归实现DFS遍历： ``` void dfs(int u) { visited[u] = true; // 标记该节点已被访问 for(int v = 0; v < n; v++) { // 枚举该节点的所有邻接点 if(!visited[v] && matrix[u][v]) { // 如果该邻接点未被访问且与该节点相邻 dfs(v); // 则访问该邻接点 } } } ``` 广度优先遍历（BFS）也是一种对图进行遍历的方式，遵循“先访问距离起点最近的节点”的原则。具体来说，该算法从某个节点开始遍历，将其入队，然后访问其所有的邻接点，并将其邻接点入队。然后从队首取出下一个节点，重复上述步骤，直到所有的节点都被遍历完毕。BFS遍历过的节点，会在遍历结束后形成一棵广度优先搜索树。对于邻接矩阵，我们可以通过队列实现BFS遍历： ``` void bfs(int u) { queue<int> q; q.push(u); // 将起点入队 visited[u] = true; // 标记该节点已被访问 while(!q.empty()) { // 如果队列非空 int u = q.front(); // 取出队首节点 q.pop(); for(int v = 0; v < n; v++) { // 枚举该节点的所有邻接点 if(!visited[v] && matrix[u][v]) { // 如果该邻接点未被访问且与该节点相邻 visited[v] = true; // 标记该节点已被访问 q.push(v); // 将该邻接点入队 } } } } ``` 总之，邻接矩阵是图的一种常见表示方法，DFS和BFS遍历是对图进行遍历的常用算法，它们可以通过递归和队列实现。掌握邻接矩阵的DFS和BFS遍历，可以更好地理解图的相关算法和数据结构，也有助于解决各种实际问题。 ### 回答3： 邻接矩阵是图的一种常见存储方式。深度优先遍历（DFS）和广度优先遍历（BFS）是针对图进行的两种遍历方式。下面将详细解释邻接矩阵的DFS和BFS的过程和实现方法。 邻接矩阵的DFS遍历： 深度优先遍历通常使用递归的方式来实现。具体的深度优先遍历邻接矩阵的过程如下： 1. 从一个顶点开始进行遍历； 2. 访问该顶点，并标记该顶点为已访问； 3. 从该顶点出发，找到一个未被访问过的相邻顶点，标记该顶点为已访问，然后递归到该顶点继续递归遍历； 4. 如果该顶点没有相邻未访问过的顶点，则回溯到最近一个有未访问过相邻顶点的顶点，然后继续递归遍历其它相邻顶点。 邻接矩阵的BFS遍历： 广度优先遍历则使用队列的方式来实现。具体的广度优先遍历邻接矩阵的过程如下： 1. 从一个顶点开始进行遍历； 2. 将该顶点加入队列中，并标记该顶点为已访问； 3. 从队列中取出一个未被访问过的顶点，访问该顶点，并将其未被访问过的相邻顶点加入队列中，并标记这些顶点为已访问； 4. 重复步骤3直到队列为空。 邻接矩阵的DFS和BFS的时间复杂度都为O（V^2），其中V为顶点数。DFS相对BFS来说，更适用于查找路径的问题，快速查找到节点之间的路径信息；BFS适用于确定最短路径和寻找最近解问题。 总而言之，邻接矩阵是一种常见的图的存储方式，DFS和BFS是对图的两种常用遍历方式。它们各自有适用性，要根据具体情况进行选择。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值