实验六 图的操作实现

已于 2023-06-09 21:48:30 修改
阅读量322 收藏 3
点赞数 1
文章标签： 算法 数据结构 c++ 图论
于 2023-06-09 21:40:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63708766/article/details/131135351
版权

一、实验目的

1、 理解图的存储结构与基本操作；

2、 掌握图的创建过程

 

二、实验内容

    1.根据下图，采用邻接矩阵的存储结构保存此图，并打印出邻接矩阵。

图的创建代码参考教材.

提示:首先根据给出的图结构得出该图的顶点集和边集，调用相应的函数生成图的邻接矩阵，并打印出邻接矩阵。

2.根据上一题的邻接矩阵，编程实现该图的深度与广度优先遍历算法，从顶点1开始遍历，分别输出深度与广度优先遍历序列。

3.选做题:单源最短路径问题

问题描述:求从有向图的某一结点出发到其余各结点的最短路径。

基本要求:

（1）有向图采用邻接矩阵表示。

（2）单源最短路径问题采用Dijkstra算法。

（3）输出有向图中从源结点A到其余各结点的最短路径和最短路径值。

三、【实验源代码】

 头文件
typedef struct
 {
 	int list[100];
 	int size;
 }SequenceList;
 
 
 int ListInitiate(SequenceList *L)
 {
 	L->size = 0;
 }
 
 
 int ListInsert(SequenceList *L,int i, char x)
 {
 	int j;
 	if(L->size >= 100)
 	{
 		printf("顺序表已满\n");
 		return 0;
 	}
 	else if (i<0 || i>L->size)
 	{
 		printf("不合法");
 		return 0;
 	}
 	else
 	{
 		for(j=L->size;j>i;j--)
 			L->list[j]=L->list[j-1];
 		L->list[i]=x;
 		L->size ++;
 		return 1;
 	}
 }
 int ListLength(SequenceList L)
 {
 	return L.size;
 }
 
 typedef struct
 {
 	SequenceList Vertices;
 	int edge[100][100];
 	int numOfEdges;
 }MatrixGraph;
 
 void Initiate(MatrixGraph *G,int n)
 {
 	int i,j;
 	for(i=0;i<n;i++)
 	{
 		for(j=0;j<n;j++)
 		{
 		 G->edge[i][j]=0;
 		
		}
	}
	G->numOfEdges=0;
	ListInitiate(&G->Vertices) ;
 }
 
 void InsertVertex(MatrixGraph *G,int vertex)
 {
 	ListInsert(&G->Vertices,G->Vertices.size,vertex);
 }
 
 void InsertEdge(MatrixGraph *G,int v1,int v2)
 {
 	if(v1<0||v1>=G->Vertices.size||v2<0||v2>=G->Vertices.size)
 	{
 		printf("参数错误");
		exit(1);
	 }
	 G->edge[v1][v2]=1;
	 G->edge[v2][v1]=1;
	 G->numOfEdges++;
 }
 
 typedef struct
 {
 	int row,col;
 }RowCol;
 
 void CreatGraph(MatrixGraph *G,int V[],int n,RowCol E[],int e)
 {
 	int i,k;
 	Initiate(G,n);
 	for(i=0;i<n;i++)
 		InsertVertex(G,V[i]);
 	for(k=0;k<e;k++)
 		InsertEdge(G,E[k].row,E[k].col);
 }
int visit_dfs[100];
void dfs(MatrixGraph G,int i)
{
	int j;
    visit_dfs[i]=1;
	printf("%c ",G.Vertices.list[i]);
	for(j=0;j<G.numOfEdges ;j++)
	{
		if(G.edge [i][j]==1&&!visit_dfs[j])
		dfs(G,j);
	}
}
void dfstraverse(MatrixGraph G)
{
	int i;
	for(i=0;i<G.numOfEdges ;i++)
	{
		visit_dfs[i]=0;
	}
	for(i=0;i<G.numOfEdges ;i++)
	{
		if(!visit_dfs[i])
		dfs(G,i);
	}
}
typedef struct Qnode
{
	int data;
	struct Qnode *next;
}Qnode, *Qptr;     //定义节点

typedef struct LINKQUEUE
{
	Qptr front;
	Qptr rear;
}LinkQueue;       //定义队首、队尾指针
void InitQueue(LinkQueue *q) //队列初始化
{
	//定义头结点，队首队尾都指向头结点
	Qptr firstnode = (Qptr)malloc(sizeof(Qnode));
	q->front = q->rear = firstnode;
	if (!q->front)
	{
		exit(0);
	}
	q->front->next = NULL;
}
void PushQueue(LinkQueue *q, int e) 
{
	//在队尾插入元素
	Qptr p = (Qptr)malloc(sizeof(Qnode));
	if (!p)
	{
		exit(0);
	}
	p->data = e;
	p->next = NULL;
	q->rear->next = p;
	q->rear = p;
}
void DetQueue(LinkQueue *q, int e)
{
	//出队列在队首进行
	if (q->front == q->rear)
	{
		printf("队列中无元素！\n");
		exit(0);
	}
	Qptr p = q->front->next;
	e = p->data;
	q->front->next = p->next;
	if (q->rear == p)
	{
		q->rear = q->front;
	}
	free(p);
}
//检验是否为空
int QueueEmpty(LinkQueue *q)
{
	if (q->front == q->rear)
		return 0;
	else
		return 1;
}
int visited[100];
void BFSTraverse(MatrixGraph G)
{
	int k;
	int i,j;
	LinkQueue Q;
	InitQueue(&Q);
	for (i = 0; i < G.numOfEdges ; i++)
	{
		visited[i] = 0; //初始化标记数组
	}
	for (i = 0; i < G.numOfEdges ; i++)
	{
		if (!visited[i])
		{
			visited[i] = 1;
			printf("%c ", G.Vertices .list[i]);
			PushQueue(&Q, i);
		}
		while (!QueueEmpty(&Q))
		{
			DetQueue(&Q, k);
			for ( j = 0; j < G.numOfEdges ; j++)
			{
				if (G.edge [k][j] == 1 && !visited[j])
				{
					visited[j] = 1;
					printf("%c", G.Vertices .list[j]);
					PushQueue(&Q, j);
				}
			}
		}
	}
}
主函数
#include<stdio.h>
#include<stdlib.h>
#include"MGraph.h"
void main()
 {
 	MatrixGraph g1;
 	int a[]={'1','2','3','4','5'};
 	RowCol rc[]={{0,1},{0,2},{0,3},{0,4},{1,3},{2,4}};
 	int n=5,e=6;
 	int i,j;
 	CreatGraph(&g1,a,n,rc,e);
 	printf("顶点集合为：\n");
 	for(i=0;i<g1.Vertices.size;i++)
 	printf("%c ",g1.Vertices.list[i]);
 	printf("\n");
 	printf("邻接矩阵为：\n");
 	for(i=0;i<g1.Vertices.size;i++)
 	printf("%5c",g1.Vertices.list[i]);
 	printf("\n\n");
 	for(i=0;i<g1.Vertices.size;i++)
 	{
 		printf("%d",i+1);
 		for(j=0;j<g1.Vertices.size;j++)
 		printf("%5d",g1.edge[i][j]);
 		printf("\n");
 	}
 	printf("深度优先遍历:\n");
 	dfstraverse(g1);
 	printf("\n广度优先遍历：\n");
	BFSTraverse(g1);

}
选做题
头文件
typedef struct
 {
 	int list[100];
 	int size;
 }SequenceList;
 
 
 int ListInitiate(SequenceList *L)
 {
 	L->size = 0;
 }
 
 
 int ListInsert(SequenceList *L,int i, char x)
 {
 	int j;
 	if(L->size >= 100)
 	{
 		printf("顺序表已满\n");
 		return 0;
 	}
 	else if (i<0 || i>L->size)
 	{
 		printf("不合法");
 		return 0;
 	}
 	else
 	{
 		for(j=L->size;j>i;j--)
 			L->list[j]=L->list[j-1];
 		L->list[i]=x;
 		L->size ++;
 		return 1;
 	}
 }
 int ListLength(SequenceList L)
 {
 	return L.size;
 }
 
 typedef struct
 {
 	SequenceList Vertices;
 	int edge[100][100];
 	int numOfEdges;
 }MatrixGraph;
 void Initiate(MatrixGraph *G,int n)
 {
 	int i,j;
 	for(i=0;i<n;i++)
 	{
 		for(j=0;j<n;j++)
 		{
 			if(i==j)
 		    G->edge[i][j]=0;
 		    else
 		    G->edge [i][j]=666;
		}
	}
	G->numOfEdges=0;
	ListInitiate(&G->Vertices) ;
 }
 void InsertVertex(MatrixGraph *G,int vertex)
 {
 	ListInsert(&G->Vertices,G->Vertices.size,vertex);
 }
 
 void InsertEdge(MatrixGraph *G,int v1,int v2,int w)
 {
 	if(v1<0||v1>=G->Vertices.size||v2<0||v2>=G->Vertices.size)
 	{
 		printf("参数错误");
		exit(1);
	 }
	 G->edge[v1][v2]=w;
	 G->numOfEdges++;
 }
 typedef struct
 {
 	int row,col,w;
 }RowCol;
 
 void CreatGraph(MatrixGraph *G,int V[],int n,RowCol E[],int e)
 {
 	int i,k;
 	Initiate(G,n);
 	for(i=0;i<n;i++)
 		InsertVertex(G,V[i]);
 	for(k=0;k<e;k++)
 		InsertEdge(G,E[k].row,E[k].col,E[k].w);
 }
主函数
#include<stdio.h>
#include<stdlib.h>
#include"mmm.h"
 void dijkstra(MatrixGraph G,int V0,int *sn,int *sw)
{
	int v,w,k,min;
	int final[G.Vertices.size];//标志数组，若顶点Vi最短路径已知，则final[i]=1;
	for(v=0;v<G.Vertices.size;v++){
		final[v]=0;
		sn[v]=0;
		sw[v]=G.edge[V0][v];
	}
	sw[V0]=0;
	final[V0]=1;
	//初始化完成，主循环开始
	for(v=1;v<G.Vertices.size;v++)
	{   //每次循环确定V0到一个顶点的最短路径 
		min=666;  //初始化最小值min 
		for(w=0;w<G.Vertices.size;w++)
		{    //遍历寻找离V0最近的点
			if(!final[w]&&sw[w]<min)
			{   //如果Vw的最短路径还没找到且w到V0的权值比min小 
				k=w;    //k存储离V0最近的点的下边 
				min=sw[w];
			 //那么顶点Vw离V0更近 
			} 
		} 
		final[k]=1;  //Vk是离V0最近的点，则Vk的最短路径已经找到，所以标志改为1 
	    for(w=0;w<G.Vertices.size;w++){
	    	if(!final[w]&&(min+G.edge[k][w])<sw[w]){  
//如果顶点Vw的最短路径未确定且经过VK的路径比V0直达的路径短的话 
	    		sw[w]=min+G.edge[k][w];
	    		sn[w]=k;  //经过Vk的路径更短，则其前驱下标为k 
			}
		} 
	} 
	sn[0]=-1;
}
void prin(int n ,int *sn)
{
	int a[10]={0},i=1,j=n,q=0;
	a[0]=n;
	while(1)
	{
		if(sn[j]==-1)
		break;
		a[i]=sn[j];
		j=a[i];
		i++;
	}
	q=i;
	for(i=q-1;i>-1;i--)
	printf("%c ",a[i]+65);
	
}
void main()
{
	MatrixGraph g1;
 	int a[]={'A','B','C','D','E','F'};
 	RowCol rc[]={{0,2,5},{0,3,30},{1,0,2},{1,4,8},{2,1,15},{2,5,7},{4,3,4},{5,3,10},{5,4,18}};
 	int n=6,e=9;
 	int i,j;
 	CreatGraph(&g1,a,n,rc,e);
 	printf("顶点集合为：\n");
 	for(i=0;i<g1.Vertices.size;i++)
 	printf("%c ",g1.Vertices.list[i]);
 	printf("\n");
 	printf("邻接矩阵为：\n");
 	for(i=0;i<g1.Vertices.size;i++)
 	printf("%5c",g1.Vertices.list[i]);
 	printf("\n\n");
 	for(i=0;i<g1.Vertices.size;i++)
 	{
 		printf("%c",65+i);
 		for(j=0;j<g1.Vertices.size;j++)
 		printf("%5d",g1.edge[i][j]);
 		printf("\n");
 	}
 	int sn[100],v0=0;
 	int sw[100];
 	dijkstra(g1,v0,sn,sw);
    printf("从顶点A到其他各项顶点的最短距离为:\n");
 	for(i=0;i<g1.Vertices.size;i++)
 		printf("到顶点%c的最短距离为%d\n",65+i,sw[i]);	
 	printf("path数组:\n");	
 	for(i=0;i<g1.Vertices.size;i++)
 	    printf("%d  ",sn[i]);
 	printf("\n");
 	printf("A到其他点的最短路:\n");
 	for(i=1;i<g1.Vertices.size;i++)
 	{
 		prin(i,sn);
 		printf("\n");
 	 }	
}

跳舞的muse
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
实验六 图基本操作的编程实现
02-09
图基本操作的编程实现（2学时，验证型），掌握图的建立、遍历、插入、删除等基本操作的编程实现，存储结构可以在顺序结构、链接结构、联合使用多种结构等中任选，也可以全部实现。也鼓励学生利用基本操作进行一些...
数据与结构实验六：图操作及应用
最新发布
m0_73709731的博客
11-04 191
循环：遍历distance数组，找distance数组中属于旧图中的点，其中distance最小的那个结点循环：遍历distance数组，找distance数组中属于旧图中的点，其中distance最小的那个结点。：此数组是用来表示标号对应的结点是否已经被添加到新图中（因为只有旧图中的点我们才需要添加到新图中，并且只有旧图中点到源点的距离，我们才需要进行更新）其中N为图中结点的个数。自己编写代码的时候注意，书上仅仅是给出了最短路径的源代码，离一个完整的程序还有距离，其中要补充图的读写的函数和定义一些常量。
《数据结构》实验报告六：图的表示与遍历
Amentos的博客
11-26 1万+
《数据结构》实验报告：图的相关概念 + 深度/广度优先遍历算法 + 拓扑排序算法 + prim算法 + dijkstra算法
深度优先遍历
xlh006的博客
09-05 7013
1、深度优先搜索遍历过程 图的深度优先搜索(Depth First Search)，和树的先序遍历比较类似。 它的思想：假设初始状态是图中所有顶点均未被访问，则从某个顶点v出发，首先访问该顶点，然后依次从它的各个未被访问的邻接点出发深度优先搜索遍历图，直至图中所有和v有路径相通的顶点都被访问到。 若此时尚有其他顶点未被访问到，则另选一个未被访问的顶点作起始点，重复上述过程，直至图中所有顶点都被...
数据结构中用邻接矩阵方式储存图，广度优先，深度优先遍历
05-30 141
数据结构中用邻接矩阵方式储存图，广度优先，深度优先遍历 数据结构中用邻接矩阵方式储存图，广度优先，深度优先遍历 - python - ITeye技术网站数据结构中用邻接矩阵方式储存图，广度优先，深度优先遍历 博客分类：c 语言数据结构J#以下是作业，用它用实现用...
图的基本操作【严蔚敏】
MooMLu的博客
04-27 3392
图的基本操作：ADT Graph{ 数据对象V：V是具有相同特性的数据元素的集合，称为顶点集。 数据关系R：R={VR} VR={<v,w>|v,w∈V且P(v,w)，<v,w>表示从v到w的弧， 谓词P(v,w)定义了弧<v,w>的意义或信息} 基本操作： CreateGraph( &G, V, VR ) 初始条件：V是图的顶
广州大学 数据结构实验报告 实验三 图的操作与实现
05-23
1、图的邻接表和邻接矩阵存储 2、图的各种遍历算法实现 3、最小生成树的算法实现 4、最短路径的算法实现
myshell_北理工操作系统实验六_
10-01
实现shell命令解析器功能，其中包含多种命令实现，模拟了shell命令
操作系统 PV操作 实验报告
06-15
一个能够完整运行出来的PV操作的实验报告，然后实验报告的结构也很完整，实验目的，实验过程，甚至实验的结果也有截图，如果有小伙伴需要，尽管下载哦
操作系统实验报告C语言实现银行家算法.doc
06-29
操作系统实验报告C语言实现银行家算法
C语言实现图及基本操作
06-22
用C语言实现图，及用C语言实现最小生成树的代码的方法
图基本操作的编程实现源码
04-24
cout<<"图的基本功能实验(存储结构邻接矩阵)"<<endl; cout<<"=================================="<<endl; cout<<"1.手工建立（有向）图 "<<endl; cout<<"2.默认数据建立图 "<<endl; cout<<"3.用邻接矩阵形式显示图 "<<endl; cout<<"4.求图的结点数和边数 "<<endl; cout<<"5.求某条边的权值 "<<endl; cout<<"6.添加结点 "<<endl; cout<<"7.删除结点 "<<endl; cout<<"8.添加边 "<<endl; cout<<"9.删除边 "<<endl; cout<<"a.深度优先遍历图 "<<endl; cout<<"s.广度优先遍历图 "<<endl; cout<<"0.退出 "<<endl;
图的基本操作实现
05-14
设计程序实现图的任意一种存储结构及相关基本操作，在此基础上实现深度优先遍历和广度优先遍历操作。
邻接矩阵的存储方式实现图的广度和深度优先遍历
giaogege666的博客
05-31 1784
在做图的邻接矩阵之前，先做好准备工作，定义存储类型，声明队列的操作（在广度优先遍历中使用） #include <stdio.h> #include <stdlib.h> #include <malloc.h> #define INFINITY INT_MAX #define MAXSIZE 20 typedef struct queue { int* base; int front; int rear; }Queue;//定义队列 void Init(Q..
基于C语言采用邻接矩阵存储方式建立图
Pdlgyxforever的博客
08-11 1657
采用邻接矩阵建立图
信管16数据结构：实验6：图的实验1
明哥的专栏
11-08 1093
实验6：图的实验1              -图的邻接矩阵存储实现 一、实验目的 1、   熟练理解图的相关概念； 2、   掌握图的邻接矩阵的存储方法的实现； 3、   学会图的遍历算法 二、 实验内容 1、自己确定一个简单无向图（顶点数、和相关结点信息）利用邻接矩阵来实现存储。实现图的构造，并完成： 1）用深度优先和广度优秀两种算法对图进行遍历，输出顶点序列数据； 2）以合
数据结构---图的邻接矩阵（创建，打印，深度优先遍历，广度优先遍历，C语言）
热门推荐
小陆同学LLR的博客
09-06 4万+
  邻接矩阵法   用一维数组图中顶点的信息，用一个二维数组存储图中边的信息（各顶点之间的邻接关系）。存储顶点之间邻接关系的二维数组称为邻接矩阵。      结点数为n的图G=(V,E)的邻接矩阵A是n*n的，将G的顶点编号为v1,v2,......vn。若（vi,vj)∈E，则A[i][j]=1，否则A[i][j]=0。   对于带权图而言，若顶点vi,vj之间有边相连，则邻接矩阵...
数据结构【完整代码】之（C语言实现【图的存储创建遍历】邻接矩阵与邻接表）
Zhou_LC的博客
11-28 1934
一、邻接矩阵 包含四个文件的代码和一张测试效果图： AdjacencyMatrix.h文件： 构建邻接矩阵的存储结构与邻接矩阵的创建函数 DBFSAdjacencyMatrix.h文件： 构建邻接矩阵的深度优先遍历与广度优先遍历函数 StackAndQueue.h文件： 应广度优先遍历所需，提供队列的基本操作 test.cpp文件： 用于测试 效果图：（如下） 效果图： AdjacencyMatrix.h文件： #include<stdio.h> #include<stdlib.h&
数据结构之图 篇一——邻接矩阵存储结构实现深度优先遍历和广度优先遍历
weixin_44566432的博客
05-14 4871
是的，今天又来啦~ 终于迎来了数据结构之图篇一，这篇博客主要实现是图的邻接矩阵存储结构实现深度优先遍历和广度优先遍历。 首先呢？介绍一下 图的存储结构：1、邻接矩阵；2、邻接表； 3、十字链表；4、邻接多重表 图的遍历方式：1、深度优先遍历； 2、广度优先遍历 最小生成树实现：1、普利姆算法； 2、克鲁斯尔算法 接着看代码 1、Node.h #ifndef NODE_H #define NODE_H class Node { public: Node(char data = 0..
操作系统实验六 编程实现文件的合并
05-18
在操作系统中，可以通过编程实现文件的合并。下面是一个简单的C语言程序，用于将两个文件合并成一个文件。 ```c #include #include int main() { FILE *fp1, *fp2, *fp3; char ch; fp1 = fopen("file1.txt",...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

跳舞的muse

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值