实验七 图的广度、深度优先遍历，拓扑排序、关键路径、最短路径、最小生成树

最新推荐文章于 2023-09-13 09:11:25 发布
最新推荐文章于 2023-09-13 09:11:25 发布
阅读量2.8k 收藏 51
点赞数 7
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43599023/article/details/87784172
版权

 1.实验目的

熟悉图的数组表示法和邻接表存储结构，掌握构造有向图和无向图的算法，在掌握以上知识的基础上，熟悉图的深度优先遍历算法，并实现。

2.实验内容

（1）图的数组表示法定义及基本操作的实现

（2）图的邻接表表示法定义和基本操作的实现

（3）写函数实现图的深度优先遍历（分别在两种结构上）

（4）在邻接表上实现拓扑排序、关键路径的求法，在邻接矩阵上实现最短路径，最小生成树的求法

 

#include<stdio.h>
#include<stdlib.h>
#define TRUE 1
#define FALSE 0
#define ERROR 0
#define OK 1
#define OVERFLOW -2

#define INFINITY 1000	//最大值
#define MAX_VERTEX_NUM 20   //最大顶点数
#define STACK_INIT_SIZE 100
#define MAXQSIZE 100
typedef int  QElemType;


typedef struct {
	QElemType *base;
	int front;
	int rear;
}SqQueue;


typedef enum { DG, DN, UDG, UDN } GraphKind;//{有向图，有向网，无向图，无向网}
typedef int Status;
typedef int VRType;
typedef int InfoType;
typedef char VertexType;//数据类型


typedef struct ArcCell {
	VRType adj;//VRType顶点关系类型，对于无权图用0,1表示相等否
						//对带权图，则为权值类型
	InfoType *info;//表示该弧相关信息指针
} ArcCell, AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];


typedef struct {
	VertexType vexs[MAX_VERTEX_NUM];//顶点向量
	AdjMatrix arcs;//邻接矩阵,各边权值
	int vexnum;//图的当前顶点数
	int arcnum;//图的弧数
	GraphKind kind;//图的种类标志
} MGraph;


Status QueueEmpty(SqQueue Q)
{
	if (Q.front == Q.rear)
		return OK;
	else
		return ERROR;
}


Status InitQueue(SqQueue *Q)
{
	Q->base = (QElemType*)malloc(MAXQSIZE * sizeof(QElemType));
	if (!Q->base)
		return OVERFLOW;
	Q->front = Q->rear = 0;
	return OK;
}


int QueueLength(SqQueue Q)
{
	return (Q.rear - Q.front + MAXQSIZE) % MAXQSIZE;
}


Status EnQueue(SqQueue *Q, QElemType e)
{
	if ((Q->rear + 1) % MAXQSIZE == Q->front)
		return ERROR;
	Q->base[Q->rear] = e;
	Q->rear = (Q->rear + 1) % MAXQSIZE;
	return OK;
}


Status DeQueue(SqQueue *Q, QElemType *e)
{
	if (Q->front == Q->rear)  return ERROR;
	*e = Q->base[Q->front];
	Q->front = (Q->front + 1) % MAXQSIZE;
	return OK;
}


int LocateVex(MGraph *G, VertexType v)
{
	int i;
	for (i = 0; i < G->vexnum; i++)
	{
		if (G->vexs[i] == v)
			return i;
	}
	return -1;
}


Status CreateUND(MGraph *G)
{
	int i, j, k;
	VertexType v1, v2;
	VRType w;
	printf("输入图的节点数和总边数:");
	scanf_s("%d %d", &G->vexnum, &G->arcnum);
	getchar();//接收输入节点数，边数后的
	for (i = 0; i < G->vexnum; i++) {
		printf("请输入第%d个顶点的信息：", i + 1);
		scanf_s("%c", &G->vexs[i], 1);
		getchar();//因为输入的是单个字符，要接收每次输入完之后的回车键
	}
	for (i = 0; i < G->vexnum; i++)
		for (j = 0; j < G->vexnum; j++)
		{
			G->arcs[i][j].adj = INFINITY;
		}
	for (k = 0; k < G->arcnum; k++)
	{
		printf("输入图第%d条边的两个顶点和该边的权值：", k + 1);
		scanf_s("%c %c %d", &v1, 1, &v2, 1, &w);
		getchar();//接收每次输入完之后键入的回车键
		i = LocateVex(G, v1);
		j = LocateVex(G, v2);
		G->arcs[i][j].adj = w;
		G->arcs[j][i].adj = G->arcs[i][j].adj;
	}
	return OK;
}


Status PrintGraph(MGraph G) {
	int i, j;
	printf("\n图的顶点为：");
	for (i = 0; i < G.vexnum; i++)
		printf("%c", G.vexs[i]);
	printf("\n图的邻接矩阵\n");
	printf("\t");
	for (i = 0; i < G.vexnum; i++)
		printf("\t%8c", G.vexs[i]);
	for (i = 0; i < G.vexnum; i++) {
		printf("\n\n%8c", G.vexs[i]);
		for (j = 0; j < G.vexnum; j++) {
			if (G.arcs[i][j].adj == INFINITY)
				printf("\t%8s", "00");
			else
				printf("\t%8d", G.arcs[i][j].adj);
		}
		printf("\n");
	}
	return OK;
}


typedef int Boolean;
Boolean visited[MAX_VERTEX_NUM];//访问标志数组


int FirstAdjVex(MGraph G, int v)
{//求v的第一个邻接点
	for (int i = 0; i < G.vexnum; i++)
		if (G.arcs[v][i].adj != 0)
			return i;
	return 0;
}


int NextAdjVex(MGraph G, int v, int w)
{//求v的相对于w的下一个邻接点
	int k;
	for (k = w + 1; k < G.vexnum; k++)
		if (G.arcs[v][k].adj != 0)
			return k;
	return 0;
}


void DFS(MGraph G, int v)
{
	int w;
	visited[v] = TRUE;
	printf("%2c", G.vexs[v]);
	for (w = FirstAdjVex(G, v); w > 0; w = NextAdjVex(G, v, w))
	{
		if (!visited[w])
			DFS(G, w);
	}
}


void DFSTraverse(MGraph G)
{//对图做深度优先遍历
	int v;
	for (v = 0; v < G.vexnum; v++)
		visited[v] = FALSE;//访问数组初始化，所有顶点都是未访问状态
	for (v = 0; v < G.vexnum; v++)
	{
		if (!visited[v])
			DFS(G, v);//对尚未访问的顶点调用DFS,若是连通图,只会执行一次
	}
}


void BFSTraverse(MGraph G)
{
	int v, w;
	SqQueue Q;
	for (v = 0; v < G.vexnum; v++)
		visited[v] = FALSE;
	InitQueue(&Q);//置空的辅助队列Q
	for (v = 0; v < G.vexnum; v++)
	{
		if (!visited[v])
		{//v尚未访问
			visited[v] = TRUE;
			printf("%2c", G.vexs[v]);
			EnQueue(&Q, v);//v入队列
			while (!QueueEmpty(Q))
			{
				DeQueue(&Q, &v);//队头元素出队并置为u

				for (w = 0; w < G.vexnum; ++w)
				{
					if (!visited[w] && G.arcs[v][w].adj != INFINITY)
					{
						visited[w] = TRUE;
						printf("%2c", G.vexs[w]);
						EnQueue(&Q, w);
					}
				}
				/*
				for (w = FirstAdjVex(G, u); w >= 0; w = NextAdjVex(G, u, w))
				{
					if (!visited[w] && G.arcs[v][w].adj != INFINITY)
					{//w为u的尚未访问的邻接顶点
						visited[w] = TRUE;
						printf("%2c", G.vexs[w]);
						EnQueue(&Q, w);
					}
				}
				*/
			}
		}
	}
}


int main()
{
	MGraph G;
	CreateUND(&G);
	PrintGraph(G);
	printf("图的深度优先遍历序列是:");
	DFSTraverse(G);
	printf("\n");
	printf("图的广度优先遍历序列是:");
	BFSTraverse(G);
	printf("\n");
	system("pause");
	return 0;
}

被注释掉的部分有bug暂时没找出错误，广度优先遍历函数一直不能退出

 

#include<stdio.h>
#include<stdlib.h>
#define MAX_VERTEX_NUM 20
#define maxsize 100
#define OK 1
#define TRUE 1
#define FALSE 0
#define ERROR 0
#define OVERFLOW 0
#define STACK_INIT_SIZE 100
#define MAXQSIZE 100
typedef int QElemType;
typedef char VertexType;
typedef int Status;
typedef int InfoType;

typedef struct ArcNode { //表结点类型定义
	int adjvex;//顶点位置编号
	struct ArcNode *nextarc;//指向下一表结点的指针
	InfoType *info;//该弧相关信息的指针
} ArcNode;
/* 顶点表*/
typedef struct VNode { //头结点及数组类型定义
	VertexType data;//顶点信息
	ArcNode *firstarc;//指向第一条弧
} VNode, AdjList[MAX_VERTEX_NUM];
/*图结构*/
typedef struct {
	AdjList vertices;//头结点数组
	int vexnum;//图当前顶点数
	int arcnum;//图当前弧数
} ALGraph;

typedef struct
{
	QElemType *base;
	int front;
	int rear;
}SqQueue;

Status QueueEmpty(SqQueue Q)//队列空返回1，不空返回0
{
	if (Q.rear == Q.front)
		return OK;
	else return ERROR;
}
Status InitQueue(SqQueue *Q)
{
	Q->base = (QElemType*)malloc(MAXQSIZE * sizeof(QElemType));
	if (!Q->base) return OVERFLOW;
	Q->front = Q->rear = 0;
	return OK;
}

int QueneLength(SqQueue Q)
{
	return(Q.rear - Q.front + MAXQSIZE) % MAXQSIZE;
}

Status EnQueue(SqQueue *Q, QElemType e)
{
	if ((Q->rear + 1) % MAXQSIZE == Q->front) return ERROR;
	Q->base[Q->rear] = e;
	Q->rear = (Q->rear + 1) % MAXQSIZE;
	return OK;
}

Status DeQueue(SqQueue *Q, QElemType *e)
{
	if (Q->front == Q->rear) return ERROR;
	*e = Q->base[Q->front];
	Q->front = (Q->front + 1) % MAXQSIZE;
	return OK;

}

void CreateUDG(ALGraph *G)
{//头插法建立图的邻接表结构
	printf("输入图的顶点数和边数:");
	scanf_s("%d %d", &G->vexnum, &G->arcnum);
	getchar(); //接受回车 
	printf("输入图中各个结点的值\n");
	for (int i = 1; i <= G->vexnum; i++)
	{//读入顶点信息，建顶点表
		printf("请输入第%d个顶点的信息:", i);
		scanf_s("%c", &G->vertices[i].data, 1);
		getchar();//接收回车
		G->vertices[i].firstarc = NULL;//将边表置为空表
	}
	for (int i = 1; i <= G->arcnum; i++)
	{//建立边<s,d><d,s>的信息
		int s, d;
		ArcNode*p, *q;
		printf("输入第%d条边有关联的顶点的序号:", i);
		scanf_s("%d %d", &s, &d);
		getchar();//接受回车
		p = (ArcNode*)malloc(sizeof(ArcNode));//边的指针 
		q = (ArcNode*)malloc(sizeof(ArcNode));
		p->adjvex = d;			q->adjvex = s;
		p->nextarc = G->vertices[s].firstarc;		G->vertices[s].firstarc = p;//<d,s>，逆向建立链表
		q->nextarc = G->vertices[d].firstarc;		G->vertices[d].firstarc = q;//<s,d>
	}
}

void PrintGraph(ALGraph G)
{
	int i;
	for (i = 1; i <= G.vexnum; i++)
	{
		printf("%d->", i);
		while (1)
		{
			if (G.vertices[i].firstarc == NULL)
			{
				printf("^");
				break;
			}
			printf("%d->", G.vertices[i].firstarc->adjvex);
			G.vertices[i].firstarc = G.vertices[i].firstarc->nextarc;
		}
		printf("\n");
	}
}


typedef int Boolean;
Boolean visited[maxsize];

Status(*VisitFunc)(int v, ALGraph G);

Status Print(int i, ALGraph G)
{
	printf("%2c", G.vertices[i].data);
	return OK;
}

void DFS(ALGraph G, int v)
{

	ArcNode *w;
	visited[v] = TRUE;
	VisitFunc(v, G);
	for (w = G.vertices[v].firstarc; w; w = w->nextarc)
		if (!visited[w->adjvex])  DFS(G, w->adjvex);  //对v的尚未访问的邻接顶点w调用DFS
}

void DFSTraverse(ALGraph G)
{
	int v;
	VisitFunc = Print;   //使用全局变量VisitFunc，使DFS不必设函数指针参数
	for (v = 1; v <= G.vexnum; ++v)  visited[v] = FALSE;
	for (v = 1; v <= G.vexnum; ++v)
		if (!visited[v]) DFS(G, v);//对每个未被访问的顶点调用DFS
	printf("\n");
}

void BFSTraverse(ALGraph G, Status(*Visit)(int v, ALGraph))
{
	int u, v;
	ArcNode *w;
	Visit = Print;
	for (v = 1; v <= G.vexnum; ++v)
		visited[v] = FALSE;
	SqQueue Q;
	InitQueue(&Q);//初始化
	for (v = 1; v <= G.vexnum; ++v)
		if (!visited[v])//v没有被访问
		{
			visited[v] = TRUE;
			Visit(v, G);
			EnQueue(&Q, v);//入队列
			while (!QueueEmpty(Q))
			{
				DeQueue(&Q, &u);
				w = G.vertices[u].firstarc;
				for (w = G.vertices[u].firstarc; w; w = w->nextarc)
					if (!visited[w->adjvex])//w为u的尚未访问的邻接顶点
					{
						visited[w->adjvex] = TRUE;
						Visit(w->adjvex, G);
						EnQueue(&Q, w->adjvex);
					}
			}
		}
	printf("\n");
}

int main()
{
	ALGraph G;
	CreateUDG(&G);
	PrintGraph(G);
	printf("深度优先遍历的序列是：");
	DFSTraverse(G);
	printf("广度优先遍历的序列是：");
	BFSTraverse(G, Print);
	system("pause");
	return 0;
}

 

 

 

心、若止水
关注
拓扑排序与关键路径(C++版)
02-25
拓扑排序与关键路径，在日常生活中，一项大的工程可以看作是由若干个子工程（这些子工程称为“活动” ）组成的集合，这些子工程（活动）之间必定存在一些先后关系，即某些子工程（活动）必须在其它一些子工程（活动）完成之后才能开始，我们可以用有向图来形象地表示这些子工程（活动）之间的先后关系，子工程（活动）为顶点，子工程（活动）之间的先后关系为有向边，这种有向图称为“顶点活动网络” ，又称“AOV网”
图的遍历、拓扑排序、最短路径算法
weixin_33875839的博客
08-04 257
1.DFS（深度优先搜索） 深度优先搜索算法（Depth-First-Search），是搜索算法的一种。它沿着树的深度遍历树的节点，尽可能深的搜索树的分支。当节点v的所有边都己被探寻过，搜索将回溯到发现节点v的那条边的起始节点。这一过程一直进行到已发现从源节点可达的所有节点为止。如果还存在未被发现的节点，则选择其中一个作为源节点并重复以上过程，整个进程反复进行直到所有节点都被访问为止。DFS 属...
图（深度优先遍历&广度优先遍历）
sinat_31089473的博客
08-19 733
图是一种数据结构，其中结点可以具有零个或多个相邻元素。两个结点之间的连接称为边。 结点也可以称为顶点。 图的表示方式 图的表示方式有两种：二维数组表示（邻接矩阵）；链表表示（邻接表）。 邻接矩阵 邻接矩阵是表示图形中顶点之间相邻关系的矩阵，对于n个顶点的图而言，矩阵是的row和col表示的是1....n个点。 邻接表 邻接矩阵需要为每个顶点都分配n个边的空间，其实有很多边都是不存在,会造成空间的一定损失. 邻接表的实现只关心存在的边，不关心不存在的边。因此没有空间浪费，邻接表由数组+链表
图的拓扑排序、关键路径、最短路径算法 -- C++实现
FreeeLinux's blog
08-20 7780
一：拓扑排序 对一个有向无环图(Directed Acyclic Graph简称DAG)G进行拓扑排序，是将G中所有顶点排成一个线性序列，使得图中任意一对顶点u和v，若边(u,v)∈E(G)，则u在线性序列中出现在v之前。通常，这样的线性序列称为满足拓扑次序(Topological Order)的序列，简称拓扑序列。 拓扑排序就是要找到入度为0的顶点，并依次压栈。首先将栈顶顶点输出，删除以此顶
实验-图的深度优先遍历和广度优先遍历
weixin_43729631的博客
12-04 1542
1.图的定义 图（graph）是由一些点（vertex）和这些点之间的连线（edge）所组成的；其中，点通常称为顶点（vertex），而点到点之间的连线通常称之为边或者弧（edge）。通常记为G=（V,E）。 2.图的分类 图通常分为有向图和无向图，而其表示表示方式分为邻接矩阵和邻接链表 4.深度优先搜索（DFS） 图的深度优先算法有点类似于树的前序遍历，首先图中的顶点均未被访问，确定某一顶点，从...
java 深度优先遍历、广度优先遍历、最短路径、最小生成树
05-13
本文将深入探讨Java中实现的四个核心图算法：深度优先遍历（DFS）、广度优先遍历（BFS）、最短路径算法以及最小生成树算法。 首先，**深度优先遍历（DFS）**是一种用于遍历或搜索树或图的算法。它从根节点开始，尽...
数据结构 广度 深度 拓扑 最短路径 最小生成树
10-21
在本主题中，我们将深入探讨“广度优先搜索”（BFS）、“深度优先搜索”（DFS）、“拓扑排序”、“最短路径算法”以及“最小生成树”这五个关键知识点，并以C语言作为实现工具。 首先，让我们从广度优先搜索开始。...
图的深度广度遍历，关键路径和最短路径
05-31
通过深度优先或广度优先遍历，结合拓扑排序和松弛操作，可以找到图的关键路径。 最短路径算法是解决网络流量、路由选择等问题的核心，比如Dijkstra算法和Floyd-Warshall算法。Dijkstra算法适用于有权图，它通过维护...
图 拓扑排序 深度搜索 广度搜索 最小生成树
11-28
在这个主题中，我们将深入探讨“图”的核心概念，以及与之相关的拓扑排序、深度优先搜索（DFS）、广度优先搜索（BFS）和最小生成树（Minimum Spanning Tree, MST）。 首先，**图** 是由节点（也称为顶点）和边组成...
数据结构+广度+深度+拓扑+最短路径+最小生成树.
03-24
在本压缩包中，包含了一系列与数据结构及其应用相关的主题：广度优先搜索（BFS）、深度优先搜索（DFS）、拓扑排序、最短路径算法以及最小生成树。这些知识点都是解决复杂问题和优化算法设计的基础。 首先，让我们...
图的拓扑排序及关键路径C++实现（基于邻接表）
qq_40637903的博客
09-10 1214
AOV网：顶点表示活动，弧表示活动间的优先关系的有向图。无有向环。 AOE网：顶点表示事件，弧表示活动，权表示活动持续的时间的有向无环图。 1.拓扑排序（AOV网） const int MAX_VERTEX_NUM = 20; //图的邻接表存储：对图的每个顶点建立一个单链表。需要两种类型的节点。一种是表头节点(数量=图的顶点数)，以向量形式存储，以便随机访问任一顶点的链表； //一种是与表头节点表示的顶点邻接的顶点，链接到相应表头节点后面 //与表头节点表示的顶点邻接的顶点的节点，包括一个顶点的数据域ad
数据结构与算法——图的深度优先和广度优先遍历 实验报告及代码
最新发布
weixin_45791919的博客
09-13 887
(1)建立邻接矩阵表示的图 (2)实现邻接矩阵表示的图的深度优先遍历、广度优先遍历
C++图的点+边存储结构以及最小生成树、拓扑排序、最短路径算法实现
精致的灰的博客
03-08 3934
文章目录图的点+边存储结构插入操作BFS（广度优先遍历）DFS（深度优先遍历）拓扑排序不使用入度的拓扑排序最小生成树Kruskal算法Prime算法最短路径---Dijkstra算法使用加强堆优化Dijkstra算法 图的点+边存储结构 相对于邻接矩阵和邻接表的结构，图的点+边的存储结构能够存储更多信息，因此更容易获取每个点的入度和出度以及对应的边，方便实现最小生成树、最短路径以及拓扑排序等算法。 另外，邻接表和邻接矩阵等存储方式与点+边的存储方式可以相互转化，实现算法接口的复用，所以当传入的参数是邻接表
拓扑排序，关键路径及最短路径
m0_37976933的博客
04-01 1030
拓扑排序： 作用：判断有向图是否有环 做法：1在有向图中选取一个没有前驱（没有弧头指向的）的顶点且输出之 2从图中删除该顶点和所有以他为尾的弧 时间复杂度：O(n+e) n为顶点数，e为边数 关键路径： 路径长度最长的路径为关键路径 目的：辨别哪些是关键活动 为什么是最长呢？依我愚见，因为关键工程要花最多时间，就算其他工程就算完工了也无用，还要等这些时间花得比较多的工程。 最短路径 1：求某个...
图论基础算法（C/C++）：最短路径：最小生成树，拓扑排序举例
weixin_40371649的博客
08-31 796
目录宽度优先遍历求最短路径Prim算法求最小生成树Kruskal求最小生成树dijkstra算法求最短路径拓扑排序算法总结 宽度优先遍历求最短路径 txt文件如下 7 8 1 2 1 4 2 3 4 3 2 6 3 5 4 5 5 7 如图，我们求各节点到节点1的距离，只需在遍历过程增加一个数组存放距离，且在访问节点过程中距离+1即可。注意有向图和无向图皆可。 //无向图宽度优先遍历求最短路径 #include<iostream> #include<vector> #inc
数据结构实验6 ：图的存储与遍历（邻接矩阵的深度优先遍历DFS和邻接表的广度优先遍历BFS）
m0_62283830的博客
11-10 3838
数据结构实验6 ：图的存储与遍历（邻接矩阵的深度优先遍历DFS和邻接表的广度优先遍历BFS）
数据结构与算法C++实现------图的邻接表构建，拓扑排序及关键路径
m0_63211569的博客
12-05 1125
通过邻接表实现图的关键路径，包含是事件最早发生时间ve，事件最迟发生时间vl，活动最早开始时间ee，活动最晚开始时间el
数据结构 实验四 图 邻接矩阵 邻接表 深度或广度优先搜索
weixin_51733609的博客
12-13 1243
数据结构 实验四 图 邻接矩阵 邻接表 深度或广度优先搜索
实验10、构造无向图（算法7.1），深度和广度遍历 （简单易懂，注释超级全，代码可以直接运行）
于笨笨的博客
09-24 1441
实验10、构造无向图（算法7.1），深度和广度遍历 （简单易懂，注释超级全，代码可以直接运行） 恭喜你，这是数据结构的最后一个实验啦，实验序号可能不对，但是饰演的数量和顺序是一个不错der （1）实验目的 通过该实验，使学生掌握图的几种存储结构，理解图的深度优先和广度优先遍历算法的思想和实现办法， （2）实验内容 实现教材算法7.2利用邻接矩阵构造无向图的算法，提供从邻接矩阵获得邻接表的功能，在此基础上进行深度优先遍历和广度优先遍历。 （3）参考界面 （4）验收/测试用例  创建所示无向图 屏幕输出邻接
"图数据结构代码整理与应用：最小生成树、关键路径、广度优先、深度优先遍历
本文将对图的基本概念进行介绍，并讨论图的一些常见应用，如最小生成树、关键路径、图的广度优先和深度优先遍历。此外，还将给出堆排序的代码实现。 一、图的基本概念 图是由节点和连接节点的边组成的一种数据结构...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值