严蔚敏数据结构图的深度与广度优先遍历

已于 2022-05-09 09:21:44 修改
阅读量452 收藏 4
点赞数
文章标签： 数据结构 深度优先 c语言
于 2022-05-08 16:41:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/laohuchishizi/article/details/124649981
版权

 头文件Graph.h

#include <stdio.h>
#include <string.h>
#define OK 1
#define INFINITY 32767
#define MAX_VERTEX_NUM 30
#define MAXINFOLEN 30
#define ERROR 0
#define OVERFLOW -1
#define MAXVERTEXLEN 30
#define FALSE 0
#define TRUE 1
typedef int Status;
typedef enum { DG, DN, UDG, UDN }GraphKind;
typedef int VRType;
typedef int InfoType;
typedef char* VertexType;
typedef struct ArcCell
{
	VRType adj;
	InfoType* info;
}ArcCell, AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
typedef struct
{
	VertexType vexs[MAX_VERTEX_NUM];
	AdjMatrix arcs;
	int vexnum, arcnum;
	GraphKind kind;
}MGraph;
Status CreatGraph(MGraph* G)
{
	printf("请输入图的类型\n");
	scanf("%d", &(G->kind));
	switch (G->kind)
	{
	case DG:return(CreatDG(G)); break;
	case DN:return(CreatDN(G)); break;
	case UDG:return(CreatUDG(G)); break;
	case UDN:return(CreatUDN(G)); break;
	default: return ERROR;
	}
}
Status CreatDG(MGraph* G)
{
	printf("请依次输入图的总结点数，弧数，以及是弧是否需要额外信息，无额外信息输入0，有额外信息输入1\n");
	int info;
	scanf("%d%d%d", &(G->vexnum), &(G->arcnum), &info);
	getchar();
	printf("请输入%d个顶点的描述\n", G->vexnum);
	for (int i = 0; i < G->vexnum; i++)
	{
		G->vexs[i] = (VertexType)malloc(sizeof(char) * MAXVERTEXLEN);
		if (!G->vexs[i]) exit(OVERFLOW);
		gets(G->vexs[i]);
	}
	for(int i=0;i<G->vexnum;i++)
		for (int j = 0; j < G->vexnum; j++)
		{
			G->arcs[i][j].adj = 0;
			G->arcs[i][j].info = NULL;
		}
	int tail, head;
	char* ch;
	ch = (char*)malloc(sizeof(char) * MAXVERTEXLEN);
	if (!ch) exit(OVERFLOW);
	for (int i = 0; i < G->arcnum; i++)
	{
		printf("请输入第%d个顶点关系\n", i + 1);
		printf("请输入它的弧尾顶点描述\n");
		gets(ch);
		for (int j = 0; j < G->vexnum; j++)
			if (strcmp(ch, G->vexs[j]) == 0)
			{
				tail = j;
				break;
			}
		printf("请输入它的弧头顶点描述\n");
		gets(ch);
		for (int j = 0; j < G->vexnum; j++)
			if (strcmp(ch, G->vexs[j]) == 0)
			{
				head = j;
				break;
			}
		G->arcs[tail][head].adj = 1;
		if (info)
		{
			G->arcs[tail][head].info = (InfoType*)malloc(sizeof(InfoType) * MAXINFOLEN);
			if (!G->arcs[tail][head].info) exit(OVERFLOW);
			printf("请输入其信息\n");
			gets(G->arcs[tail][head].info);
		}
	}
	return OK;
}
Status CreatDN(MGraph* G)
{
	printf("请依次输入图的总结点数，弧数，以及是弧是否需要额外信息，无额外信息输入0，有额外信息输入1\n");
	int info;
	scanf("%d%d%d", &(G->vexnum), &(G->arcnum), &info);
	getchar();
	printf("请输入%d个顶点的描述\n", G->vexnum);
	for (int i = 0; i < G->vexnum; i++)
	{
		G->vexs[i] = (VertexType)malloc(sizeof(char) * MAXVERTEXLEN);
		if (!G->vexs[i]) exit(OVERFLOW);
		gets(G->vexs[i]);
	}
	for (int i = 0; i < G->vexnum; i++)
		for (int j = 0; j < G->vexnum; j++)
		{
			G->arcs[i][j].adj = INFINITY;
			G->arcs[i][j].info = NULL;
		}
	int tail, head;
	char* ch;
	ch = (char*)malloc(sizeof(char) * MAXVERTEXLEN);
	if (!ch) exit(OVERFLOW);
	for (int i = 0; i < G->arcnum; i++)
	{
		printf("请输入第%d个顶点关系\n", i + 1);
		printf("请输入它的弧尾顶点描述\n");
		gets(ch);
		for (int j = 0; j < G->vexnum; j++)
			if (strcmp(ch, G->vexs[j]) == 0)
			{
				tail = j;
				break;
			}
		printf("请输入它的弧头顶点描述\n");
		gets(ch);
		for (int j = 0; j < G->vexnum; j++)
			if (strcmp(ch, G->vexs[j]) == 0)
			{
				head = j;
				break;
			}
		printf("请输入弧的权值\n");
		scanf("%d", &(G->arcs[tail][head]));
		getchar();
		if (info)
		{
			G->arcs[tail][head].info = (InfoType*)malloc(sizeof(InfoType) * MAXINFOLEN);
			if (!G->arcs[tail][head].info) exit(OVERFLOW);
			printf("请输入其信息\n");
			gets(G->arcs[tail][head].info);
		}
	}
	return OK;
}
Status CreatUDG(MGraph* G)
{
	printf("请依次输入图的总结点数，弧数，以及是弧是否需要额外信息，无额外信息输入0，有额外信息输入1\n");
	int info;
	scanf("%d%d%d", &(G->vexnum), &(G->arcnum), &info);
	getchar();
	printf("请输入%d个顶点的描述\n", G->vexnum);
	for (int i = 0; i < G->vexnum; i++)
	{
		G->vexs[i] = (VertexType)malloc(sizeof(char) * MAXVERTEXLEN);
		if (!G->vexs[i]) exit(OVERFLOW);
		gets(G->vexs[i]);
	}
	for (int i = 0; i < G->vexnum; i++)
		for (int j = 0; j < G->vexnum; j++)
		{
			G->arcs[i][j].adj = 0;
			G->arcs[i][j].info = NULL;
		}
	int vex1, vex2;
	char* ch;
	ch = (char*)malloc(sizeof(char) * MAXVERTEXLEN);
	if (!ch) exit(OVERFLOW);
	for (int i = 0; i < G->arcnum; i++)
	{
		printf("请输入第%d个顶点关系\n", i + 1);
		printf("请输入它所依附的第一个顶点的顶点描述\n");
		gets(ch);
		for (int j = 0; j < G->vexnum; j++)
			if (strcmp(ch, G->vexs[j]) == 0)
			{
				vex1 = j;
				break;
			}
		printf("请输入它所依附的第二个顶点的顶点描述\n");
		gets(ch);
		for (int j = 0; j < G->vexnum; j++)
			if (strcmp(ch, G->vexs[j]) == 0)
			{
				vex2 = j;
				break;
			}
		G->arcs[vex1][vex2].adj = 1;
		G->arcs[vex2][vex1].adj = 1;
		if (info)
		{
			G->arcs[vex1][vex2].info = (InfoType*)malloc(sizeof(InfoType) * MAXINFOLEN);
			if (!G->arcs[vex1][vex2].info) exit(OVERFLOW);
			printf("请输入其信息\n");
			gets(G->arcs[vex1][vex2].info);
			G->arcs[vex2][vex1].info = (InfoType*)malloc(sizeof(InfoType) * MAXINFOLEN);
			if (!G->arcs[vex2][vex1].info) exit(OVERFLOW);
			strcpy(G->arcs[vex2][vex1].info, G->arcs[vex1][vex2].info);
		}
	}
	return OK;
}
Status CreatUDN(MGraph* G)
{
	printf("请依次输入图的总结点数，弧数，以及是弧是否需要额外信息，无额外信息输入0，有额外信息输入1\n");
	int info;
	scanf("%d%d%d", &(G->vexnum), &(G->arcnum), &info);
	getchar();
	printf("请输入%d个顶点的描述\n", G->vexnum);
	for (int i = 0; i < G->vexnum; i++)
	{
		G->vexs[i] = (VertexType)malloc(sizeof(char) * MAXVERTEXLEN);
		if (!G->vexs[i]) exit(OVERFLOW);
		gets(G->vexs[i]);
	}
	for (int i = 0; i < G->vexnum; i++)
		for (int j = 0; j < G->vexnum; j++)
		{
			G->arcs[i][j].adj = INFINITY;
			G->arcs[i][j].info = NULL;
		}
	int vex1, vex2;
	char* ch;
	ch = (char*)malloc(sizeof(char) * MAXVERTEXLEN);
	if (!ch) exit(OVERFLOW);
	for (int i = 0; i < G->arcnum; i++)
	{
		printf("请输入第%d个顶点关系\n", i + 1);
		printf("请输入它所依附的第一个顶点的顶点描述\n");
		gets(ch);
		for (int j = 0; j < G->vexnum; j++)
			if (strcmp(ch, G->vexs[j]) == 0)
			{
				vex1 = j;
				break;
			}
		printf("请输入它所依附的第二个顶点的顶点描述\n");
		gets(ch);
		for (int j = 0; j < G->vexnum; j++)
			if (strcmp(ch, G->vexs[j]) == 0)
			{
				vex2 = j;
				break;
			}
		printf("请输入此弧权值\n");
		scanf("%d", &(G->arcs[vex1][vex2].adj));
		getchar();
		G->arcs[vex2][vex1].adj = G->arcs[vex1][vex2].adj;
		if (info)
		{
			G->arcs[vex1][vex2].info = (InfoType*)malloc(sizeof(InfoType) * MAXINFOLEN);
			if (!G->arcs[vex1][vex2].info) exit(OVERFLOW);
			printf("请输入其信息\n");
			gets(G->arcs[vex1][vex2].info);
			G->arcs[vex2][vex1].info = (InfoType*)malloc(sizeof(InfoType) * MAXINFOLEN);
			if (!G->arcs[vex2][vex1].info) exit(OVERFLOW);
			strcpy(G->arcs[vex2][vex1].info, G->arcs[vex1][vex2].info);
		}
	}
	return OK;
}
//孩子兄弟树的数据结构描述
typedef char* TElemType;
typedef struct CSNode
{
	TElemType data;
	struct CSNode* firstchild, * nextsibling;
}CSNode, * CSTree;
//队列函数
typedef CSTree QElemType;
typedef struct QNode
{
	QElemType data;
	struct QNode* next;
}QNode, * QueuePtr;
typedef struct
{
	QueuePtr front, rear;
}LinkQueue;
Status InitQueue(LinkQueue* Q)
{
	Q->front = (QNode*)malloc(sizeof(QNode));
	if (!Q->front) exit(OVERFLOW);
	Q->rear = Q->front;
	return OK;
}
Status EnQueue(LinkQueue* Q, QElemType e)
{
	QNode* p;
	p = (QNode*)malloc(sizeof(QNode));
	if (!p) exit(OVERFLOW);
	p->data = e;
	Q->rear->next = p;
	Q->rear = p;
	p->next = NULL;
	return OK;
}
Status DeQueue(LinkQueue* Q, QElemType* e)
{
	if (Q->front == Q->rear)
		return ERROR;
	*e = Q->front->next->data;
	if (Q->rear == Q->front->next)
		Q->rear = Q->front;
	QNode* p = Q->front->next;
	Q->front->next = p->next;
	free(p);
	return OK;
}
Status QueueEmpty(LinkQueue Q)
{
	if (Q.front == Q.rear)
		return TRUE;
	else
		return FALSE;
}
void PrintQueue(LinkQueue Q)
{
	QNode* p = Q.front->next;
	if (!p)
		printf("空\n");
	else
	{
		while (p)
		{
			printf("%d\t", p->data + 1);
			p = p->next;
		}
		printf("\n");
	}
}

c文件：

#include "Graph.h"
Status PutString(VertexType v)
{
	puts(v);
	return OK;
}
//图的深度优先遍历，邻接矩阵存储图
int visited[MAX_VERTEX_NUM];
void DFS(MGraph G, int w, Status(*Visit)(VertexType e))
{
	visited[w] = TRUE;
	Visit(G.vexs[w]);
	for (int v = 0; v < G.vexnum; v++)
	{
		if (!visited[v] && G.arcs[w][v].adj == 1)
			DFS(G, v, Visit);
	}
}
void DFSTraverse(MGraph G, Status(*Visit)(VertexType e))
{
	for (int i = 0; i < G.vexnum; i++)
		visited[i] = FALSE;
	for (int i = 0; i < G.vexnum; i++)
	{
		if (!visited[i])
			DFS(G, i, Visit);
	}
	return OK;
}
//广度优先遍历邻接矩阵存储图
void BFSTraverse(MGraph G, Status(*Visit)(VertexType e))
{
	LinkQueue* Q;
	Q = (LinkQueue*)malloc(sizeof(LinkQueue));
	if (!Q) exit(OVERFLOW);
	InitQueue(Q);
	for (int i = 0; i < G.vexnum; i++)
		visited[i] = FALSE;
	for (int i = 0; i < G.vexnum; i++)
	{
		if (!visited[i])
		{
			Visit(G.vexs[i]);
			visited[i] = TRUE;
			EnQueue(Q, i);
			while (!QueueEmpty(*Q))
			{
				int k;
				DeQueue(Q, &k);
				for (int j = 0; j < G.vexnum; j++)
				{
					if (!visited[j] && G.arcs[k][j].adj)
					{
						EnQueue(Q, j);
						Visit(G.vexs[j]);
						visited[j] = TRUE;
					}
				}
			}
		}
	}
}
int main()
{
	MGraph G;
	CreatGraph(&G);
	printf("\t");
	for (int i = 0; i < G.vexnum; i++)
		printf("V%d\t", i + 1);
	printf("\n\n");
	for (int i = 0; i < G.vexnum; i++)
	{
		printf("V%d\t", i + 1);
		for (int j = 0; j < G.vexnum; j++)
			printf("%d\t", G.arcs[i][j].adj);
		printf("\n\n\n");
	}
	Status* Visit;
	Visit = PutString;
    printf("深度优先遍历结果为：\n");
	DFSTraverse(G, Visit);
    printf("广度优先遍历结果为：\n");
    BFSTraverse(G, Visit);
	return 0;
}

输入：

2
8 9 0
V1
V2
V3
V4
V5
V6
V7
V8
V1
V2
V1
V3
V2
V4
V2
V5
V4
V8
V5
V8
V3
V6
V3
V7
V6
V7

 原图：

 领接矩阵：

结果： 

 

哆啦BCD梦
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
最小生成树-Prim算法（参考 清华大学 《数据结构》 严蔚敏版）
Jasonchen1224的博客
01-28 244
最小生成树 Prim算法（参考 清华大学 《数据结构》 严蔚敏版）
Prim算法构造最小生成树
戒
03-08 4661
Prim算法 普里姆算法（Prim算法），图论中的一种算法，可在加权连通图里搜索最小生成树。 1.问题 举一个实例，画出采用Prim算法构造最小生成树的过程。 2.解析 已知图V = {…} 我们构造一棵最小生成树T 第一步：随意选取起点 第二步：在前一步的基础上寻找最小权值 第三步：继续寻找最小权值，之后以此类推，直到遍历完所有的节点。 实例： 图v如图 1.任意选择一个点 这里我们选择A点 从A点出发有两条路，一条通向B(权值为3)，一条通向D(权值为4) 我们选择权值较小的点B 此时被选中的点：A
数据结构 第五章 图——最小生成树，Prim算法，Kruskal算法
qq_40344308的博客
04-27 371
生成树： 生成树是一个图的极小连通分量： （1）包含图中所有顶点； （2）只含最少的边，如果增加一条边则会构成回路，减少一条边则会不连通（因为树是一种特殊的图，树一定是连通的，而且树中不会有回路）。 最小生成树（Minimum Spanning Tree, MST）： （1）带权连通无向图； （2）图的所有生成树中各边权值之和最小的一颗生成树。 特点： （1）一个图得最小生成树是不唯一的，但最小生...
ZJOI2019Round#1
weixin_30487317的博客
03-27 979
考的这么差二试基本不用去了 不想说什么了。就把这几天听课乱记的东西丢上来吧 这里是二试乱听课笔记ZJOI2019Round#2 ZJOI Round#1 Day1 M.《具体数学》选讲 罗煜翔-宁波市镇海中学 上升/下降阶乘幂 差分和和式 差分类似求导；和式类似积分 下降幂多项式与下降幂级数 考虑如何计算两个下降幂多项式的乘积 如何处理下降幂多项式的点值？ 下降幂级数在自然数处收敛，在其他数位...
克鲁斯卡尔算法
c__chong的博客
05-28 7891
什么是克鲁斯卡尔算法 在知道克鲁斯卡尔算法之前我们先来看一下什么是最小生成树。 最小生成树：在一个有n个结点的无向图中选出最少的边，保证所选边权相加之和最小以及该图中依然有n个结点并且n个结点连通。 一共有n个结点，要保证连通，至少需要n-1条边。 最小生成树的权值：w(t)=∑(u,v)∈tw(u,v)w(t)=\sum\limits_{(u,v)\in t}^{}w(u,v)w(t)=(u,v)∈t∑​w(u,v) 下面我们用图看一下什么是最小生成树： 在该图中，我们留下这四条边就可以保证各个结点
数据结构图的遍历实验报告
03-23
数据结构图的遍历是计算机科学中的一个核心概念，尤其在算法分析和设计中占有重要地位。本实验报告将深入探讨这一主题，结合严蔚敏教授的经典教材《数据结构》和C/C++编程语言，旨在帮助理解并实现图的遍历方法。 ...
严蔚敏版《数据结构》代码实现
01-13
6. **图**：图的遍历方式包括深度优先搜索（DFS）和广度优先搜索（BFS）。此外，还提到了有向图的十字链表表示和无向图的孩子兄弟表示。最小生成树的普里姆算法（Prim's Algorithm）和拓扑排序也在实现范围内。 7. ...
数据结构资源（严蔚敏版）.rar
05-08
7. **图**：涵盖图的定义、表示方式（邻接矩阵、邻接表），图的遍历算法（深度优先搜索、广度优先搜索）及图的应用问题，如最短路径、最小生成树。 8. **查找**：介绍顺序查找、二分查找、哈希表查找等方法，以及...
严蔚敏数据结构题集(C语言版)完整答案.doc
12-29
3. **图结构**：图用于表示对象之间的复杂关系，如邻接矩阵和邻接表是常见的图存储方式，图的遍历算法如深度优先搜索(DFS)和广度优先搜索(BFS)也是重点。 4. **排序与查找**：包括冒泡排序、插入排序、选择排序、...
数据结构_数据结构严蔚敏_
10-02
图的遍历算法包括深度优先搜索（DFS）和广度优先搜索（BFS），在解决最短路径问题、最小生成树等问题时尤为关键。 6. **哈希表**：哈希表通过哈希函数将键映射到数组索引，实现快速查找、插入和删除。良好的哈希...
普里姆(Prim)算法，数据机构，c语言，严蔚敏
12-31
16、输入任意的一个网，用普里姆(Prim)算法构造最小生成树。 ，数据机构，c语言，严蔚敏
2020-10-14 //严蔚敏《数据结构》 //最小生成树--Prim算法
weixin_45888287的博客
10-14 655
//严蔚敏《数据结构》 //最小生成树--Prim算法 //自学中，加油！ #include<iostream> #include<string> using namespace std; const int MaxVertexnum=20; const int Infinity=INT_MAX; #define InfoType string #define VRType double #define VertexType string typedef enum{DG,DN,UDG
图的深度优先遍历-C语言实现
热门推荐
鲍礼彬的CSDN博客 ~_~
10-16 3万+
#include #include #include #include #define MAXLIN 40 /*----邻接表存储结构---*/ //-----------------表节点存储结构---------- typedef struct ArcNode{                                            //结构体     int a
全局最小割 stoer-wagner与karger-stein算法
weixin_34402408的博客
12-19 1030
stoer-wagner算法 进行n轮操作，每轮操作确定一对点s,t被割开情况下的最小割，然后将s,t合并。s,t为操作中最后剩下的两个点。 操作类似prim求最大生成树，每次将与当前集合相邻的距离最大的点合并到集合中，最后剩下s,t两点。 代码来自wiki const int maxn = 550; const int inf = 1000000000; int n, r;...
无向图最小割的相关算法及其延伸
hqd_acm的专栏
09-29 1812
无向图最小割的相关算法及其延伸<br />这个题目实在太大了，因为这是一个研究了许多年发表了无数篇文章的问题，我自然也无法在短期内很好的诠释它。但为了与网上的其它文章有所区别，我打算把几个内容都揉到文章中去，但是这些都似乎在ICPC中尚无用武之地，就权当是爱好吧。<br />网络流算法自然是可以解决该问题，但是我们不作讨论。还有一类方法是90年代初期发展起来以缩图（Contraction algorithm）为基础的算法，目前最简单最高效的stoer-wagner算法是1997年发表的，它的主要思想如下：<
严蔚敏-图-存储结构-图的遍历
CodePandas
02-10 1524
数据结构学习笔记【第7章 图】 7.1 图的定义和术语 图是一种较线性表和树更为复杂的数据结构。在图形结构中，结点之间的关系是任意的，图中任意两个数据元素之间都可能相关。 在图中的数据元素通常称做顶点(Vertex)，V是顶点的有穷非空集合；VR是两个顶点之间的关系的集合。若<v,w>∈VR<v,w>∈VR<v,w>∈VR，则<v,w><v,...
最小生成树之prim算法
闲云野鹤的专栏
11-26 1029
转载地址：http://blog.chinaunix.net/uid-25324849-id-2182922.html 边赋以权值的图称为网或带权图，带权图的生成树也是带权的，生成树T各边的权值总和称为该树的权。    最小生成树（MST）：权值最小的生成树。    生成树和最小生成树的应用：要连通n个城市需要n－1条边线路。可以把边上的权值解释为线路的造价。则最小生成树表示使其造价最小
最小生成树———prim算法和kruskal算法详解
SYITwin的博客
08-23 1万+
最小生成树之prim算法（转载出处） 边赋以权值的图称为网或带权图，带权图的生成树也是带权的，生成树T各边的权值总和称为该树的权。    最小生成树（MST）：权值最小的生成树。    生成树和最小生成树的应用：要连通n个城市需要n－1条边线路。可以把边上的权值解释为线路的造价。则最小生成树表示使其造价最小的生成树。    构造网的最小生成树必须解决下面两个问题：     1、尽可能选取...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值