数据结构-图

最新推荐文章于 2024-09-20 14:26:28 发布
最新推荐文章于 2024-09-20 14:26:28 发布
阅读量926 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 数据结构 图 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WayToAccept/article/details/49475617
版权

图的基本算法

图主要是DFS+BFS，其他都可变形得到

#include<stdio.h>
#include<stdlib.h>
#define MAX 200000000//表示节点间不可达
#define NodeNum 50//假设小于50个节点
//有向图算法。无向图与有向图类似
//图的标配
//1.数组（标识是否访问过）
//2.存储结构（邻接矩阵/邻接表）
//3.访问的数据结构（BFS中队列，非递归DFS中的栈）


int path[NodeNum]={0};
int NodeMapIndex[NodeNum]={0};//将字母映射为数字
int Metrix[NodeNum][NodeNum]={0};
int visit[NodeNum]={0};//visit数组（全局，标识是否访问过）
int lowCost[NodeNum]={0};//到达每个顶点的最小代价（在Prim与Dijkstra表示的意义不同）
int dist[NodeNum][NodeNum]={0};//Floyd存储最点距离
//图的邻接表定义
typedef struct ArcNode
{
	int adjvex;
	int value;//权值
	ArcNode *nextarc;
}ArcNode;
typedef struct VNode
{
	char data;//图中的顶点数据，当然也可以是整形
	ArcNode*firstarc;
}VNode,Adjlist[NodeNum];
typedef struct
{
	Adjlist vertices;
	int vexnum,arcnum;
}AlGraph;

//创建图-邻接矩阵
int CreateGraph1()
{
	int n,i,j,value;
	scanf("%d",&n);
	if(n>0)
	{
		for(i=0;i<n;i++)
		{
			for(j=0;j<n;j++)
			{
				Metrix[i][j]=0;
			}
		}
		while(scanf("%d%d%d",&i,&j,&value)&&i>=0&&i<n&&j>=0&&j<n)
		{
			Metrix[i][j]=value;
			//如果是无向图则需要再加一个节点Metrix[j][i]=value;
		}
		return n;
	}
	else
	{
		puts("节点数不能为负！");
		return -1;
	}
}

//创建有向图-邻接表
void CreateGraph2(AlGraph &G)
{
	int n,i,j,value;
	scanf("%d",&n);
	getchar();
	if(n>0)
	{
		char ch1,ch2;
		G.vexnum=n;
		//创建n个节点
		for(i=0;i<n;)
		{
			scanf("%c",&ch1);
			getchar();
			if(ch1>='a'&&ch1<='z')
			{
				G.vertices[i].data=ch1;
				G.vertices[i].firstarc=NULL;
				NodeMapIndex[ch1-'a']=i;//将字母映射为数字
				i++;
			}
		}
		//创建弧
		G.arcnum=0;
		while(1)
		{
			//输入弧节点
			scanf("%c %c %d",&ch1,&ch2,&value);
			getchar();
			if(!(ch1>='a'&&ch1<='z'&&ch2>='a'&&ch2<='z'))
			{
				break;
			}
			//定位ch1---ch2
			ArcNode *p=(ArcNode*)malloc(sizeof(ArcNode));
			p->adjvex=NodeMapIndex[ch2-'a'];
			p->value=value;
			p->nextarc=G.vertices[NodeMapIndex[ch1-'a']].firstarc;
			G.vertices[NodeMapIndex[ch1-'a']].firstarc=p;
			G.arcnum++;
			//如果是无向图则需要再加一个节点
		}
	}
	else
	{
		puts("节点数不能为负！");
	}
}
//创建无向图-邻接表
void CreateGraph3(AlGraph &G)
{
	int n,i,j,value;
	scanf("%d",&n);
	getchar();
	if(n>0)
	{
		char ch1,ch2;
		G.vexnum=n;
		//创建n个节点
		for(i=0;i<n;)
		{
			scanf("%c",&ch1);
			getchar();
			if(ch1>='a'&&ch1<='z')
			{
				G.vertices[i].data=ch1;
				G.vertices[i].firstarc=NULL;
				NodeMapIndex[ch1-'a']=i;//将字母映射为数字
				i++;
			}
		}
		//创建弧
		G.arcnum=0;
		while(1)
		{
			//输入弧节点
			scanf("%c %c %d",&ch1,&ch2,&value);
			getchar();
			if(!(ch1>='a'&&ch1<='z'&&ch2>='a'&&ch2<='z'))
			{
				break;
			}
			//定位ch1--->ch2
			ArcNode *p=(ArcNode*)malloc(sizeof(ArcNode));
			p->adjvex=NodeMapIndex[ch2-'a'];
			p->value=value;
			p->nextarc=G.vertices[NodeMapIndex[ch1-'a']].firstarc;
			G.vertices[NodeMapIndex[ch1-'a']].firstarc=p;
			//如果是无向图则需要再加一个节点
			//定位ch2--->ch1
			p=(ArcNode*)malloc(sizeof(ArcNode));
			p->adjvex=NodeMapIndex[ch1-'a'];
			p->value=value;
			p->nextarc=G.vertices[NodeMapIndex[ch2-'a']].firstarc;
			G.vertices[NodeMapIndex[ch2-'a']].firstarc=p;
			G.arcnum++;
		}
	}
	else
	{
		puts("节点数不能为负！");
	}
}
void CrashAlGraph(AlGraph &G)
{
	for(int i=0;i<G.vexnum;i++)
	{
		visit[i]=0;
	}
	ArcNode*p,*q;
	for(int i=0;i<G.vexnum;i++)
	{
		p=G.vertices[i].firstarc;
		G.vertices[i].firstarc=NULL;
		while(p)
		{
			q=p;
			p=p->nextarc;
			free(q);
			q=NULL;
		}
	}
	puts("Crashed!");
}
void VisitNode(int v)
{
	printf("%c ",'a'+v);
}
void DFS(AlGraph G,int v)
{
	visit[v]=1;
	VisitNode(v);
	ArcNode *p=G.vertices[v].firstarc;
	for(;p;p=p->nextarc)
	{
		int w=p->adjvex;
		if(visit[w]==0)
		{
			DFS(G,w);
		}
	}
}
//非递归DFS类似于树的先序非递归
void DFS2(AlGraph G,int v)
{
	ArcNode*Stack[NodeNum],*p;
	int top=0;
	visit[v]=1;
	VisitNode(v);
	p=G.vertices[v].firstarc;
	while(top>0||p)
	{
		while(p)
		{
			if(visit[p->adjvex]==1)
			{
				p=p->nextarc;
			}
			else
			{
				visit[p->adjvex]=1;
				VisitNode(p->adjvex);
				Stack[top++]=p;
				p=G.vertices[p->adjvex].firstarc;
			}
		}
		if(top>0)
		{
			p=Stack[--top];
			p=p->nextarc;
		}
	}
}
//广度优先
void BFS(AlGraph G,int v)
{
	int Queue[NodeNum]={0};
	int front=0,rear=0;
	if(visit[v]==0)
	{
		Queue[rear++]=v;
		while(front<rear)
		{
			int u=Queue[front++];
			visit[u]=1;
			VisitNode(u);
			ArcNode *p=G.vertices[u].firstarc;
			//将所有未访问得临节点入队
			for(;p;p=p->nextarc)
			{
				int w=p->adjvex;
				if(visit[w]==0)
				{
					Queue[rear++]=w;
				}
			}

		}
	}
}
//访问图每个节点
void VisitGraph(AlGraph G)
{
	for(int i=0;i<G.vexnum;i++)
	{
		visit[i]=0;
	}
	for(int i=0;i<G.vexnum;i++)
	{
		if(visit[i]==0)
		{
			DFS2(G,i);//BFS(G,i);
		}
	}
	puts("");
	for(int i=0;i<G.vexnum;i++)
	{
		visit[i]=0;
	}
}
//判断 a 到 c 是否有路经-邻接表（a是否可到c）
int IsPath1(AlGraph G,char a,char c)
{
	DFS(G,NodeMapIndex[a-'a']);//BFS(G,NodeMapIndex[a-'a']);
	return visit[ NodeMapIndex[c-'a']];
}
//判断 a 到 c 是否有路经-邻接矩阵（可用弗洛伊德算法）
//略

//找到a到c所有的路径
void FindPath(AlGraph G,char a,char c,int len)
{
	visit[NodeMapIndex[a-'a']]=1;
	path[len++]=NodeMapIndex[a-'a'];
	if(a==c)
	{
		for(int i=0;i<len;i++)
		{
			printf("%c ",G.vertices[path[i]].data);
		}
		puts("");
	}
	else
	{
		ArcNode*p=G.vertices[NodeMapIndex[a-'a']].firstarc;
		for(;p;p=p->nextarc)
		{
			int w=p->adjvex;
			if(visit[w]==0)
			{
				FindPath(G,G.vertices[w].data,c,len);
			}
		}
	}
	visit[NodeMapIndex[a-'a']]=0;
}
//无向图的连通分量（DFS/BFS)略
//有向图的强连通分量（加点法：a->c且c->a则a,c是同一个连通分量）略

//拓扑排序(邻接表存储)
//王道
//（逆邻接表存储略）
int TopSort(AlGraph G)
{
	int i=0,j=0,top=0;
	int Degree[NodeNum]={0};
	int Stack[NodeNum]={0};
	int SortArr[NodeNum]={0};
	ArcNode*p;
	//计算所有顶点入度
	for(i=0;i<G.vexnum;i++)
	{
		p=G.vertices[i].firstarc;
		for(;p;p=p->nextarc)
		{
			int w=p->adjvex;
			Degree[w]++;
		}
	}
	//入度为0入栈
	for(i=0;i<G.vexnum;i++)
	{
		if(Degree[i]==0)
		{
			Stack[top++]=i;
		}
	}
	while(top>0)
	{
		int v=Stack[--top];
		SortArr[j++]=v;
		p=G.vertices[v].firstarc;
		//临接点入度减一为0入栈
		for(;p;p=p->nextarc)
		{
			if(--Degree[p->adjvex]==0)
			{
				Stack[top++]=p->adjvex;
			}
		}
	}
	if(j<G.vexnum)return 0;
	else
	{
		for(i=0;i<G.vexnum;i++)
		{
			VisitNode(SortArr[i]);
		}
		puts("");
		return 1;
	}
}
//DFS在确保含有拓扑序列的条件下用于输出TopSort序列
//王道
//（不能用来判断是否无环）
int finish[NodeNum]={0};
int time=0;//递归完成时间(子节点总是先于自己递归完成)
void TopDFS(AlGraph G,int v)
{
	visit[v]=1;
	ArcNode*p=G.vertices[v].firstarc;
	for(;p;p=p->nextarc)
	{
		int w=p->adjvex;
		if(visit[w]==0)
		{
			TopDFS(G,w);
		}
	}
	finish[time++]=v;
}
//以TopDFS输出拓扑序列
void TopSort2(AlGraph G)
{
	for(int i=0;i<G.vexnum;i++)
	{
		visit[i]=0;
	}
	for(int i=0;i<G.vexnum;i++)
	{
		if(visit[i]==0)
		{
			TopDFS(G,i);
		}
	}
	for(int i=time-1;i>=0;i--)
	{
		VisitNode(finish[i]);
	}
	puts("");
}

//判断图是否有环（对每个点DFS，能找到自己则有环）
//或者拓扑排序
void LoopDFS(AlGraph G,int u,int& flag)
{
	visit[u]=-1;
	ArcNode*p=G.vertices[u].firstarc;
	for(;p;p=p->nextarc)
	{
		if(visit[p->adjvex]==0)
		{
			LoopDFS(G,p->adjvex,flag);
		}
		else if(visit[p->adjvex]==-1)//在返回之前又遇到访问过的节点
		{
			flag=1;
		}
	}
	visit[u]=1;
}
int IsLoop(AlGraph G)//利用LoopDFS判断是否有环
{
	int flag=0,u=0;
	for(int i=0;i<G.vexnum;i++)
	{
		visit[i]=0;
	}
	for(int i=0;i<G.vexnum;i++)
	{
		if(visit[i]==0)
		{
			LoopDFS(G,i,flag);
		}
	}
	return flag;
}
//最小生成树prim
int Prim(AlGraph G,int u)
{
	int cost=0;
	for(int i=0;i<G.vexnum;i++)
	{
		lowCost[i]=MAX;
		visit[i]=0;
	}
	lowCost[u]=0;
	for(int i=0;i<G.vexnum;i++)
	{
		int min=MAX;
		for(int j=0;j<G.vexnum;j++)
		{
			if(visit[j]==0&&min>lowCost[j])
			{
				min=lowCost[j];
				u=j;
			}
		}
		visit[u]=1;
		VisitNode(u);
		cost+=lowCost[u];
		ArcNode*p=G.vertices[u].firstarc;
		for(;p;p=p->nextarc)
		{
			int w=p->adjvex;
			if(visit[w]==0&&lowCost[w]>p->value)
			{
				lowCost[w]=p->value;
			}
		}
	}
	return cost;
}
//单源最短路Dijkstra(不含负权)
//u--->v
int Dijkstra(AlGraph G,int u,int v)
{
	//int cost=0;
	for(int i=0;i<G.vexnum;i++)
	{
		lowCost[i]=MAX;
		visit[i]=0;
	}
	lowCost[u]=0;
	for(int i=0;i<G.vexnum;i++)
	{
		int min=MAX;
		for(int j=0;j<G.vexnum;j++)
		{
			if(visit[j]==0&&min>lowCost[j])
			{
				min=lowCost[j];
				u=j;
			}
		}
		visit[u]=1;
		//cost+=lowCost[u];
		ArcNode*p=G.vertices[u].firstarc;
		for(;p;p=p->nextarc)
		{
			int w=p->adjvex;
			//与prim算法不同之处对lowCost修改
			if(visit[w]==0&&lowCost[w]>lowCost[u]+p->value)
			{
				lowCost[w]=lowCost[u]+p->value;
			}
		}
	}
	return lowCost[v];
}
//任意顶点间最短路
//Floyd(不含负权)
void Floyd(AlGraph G)
{
	ArcNode *p;
	//初始化visit与dist矩阵
	for(int i=0;i<G.vexnum;i++)
	{
		visit[i]=0;
		for(int j=0;j<G.vexnum;j++)
		{
			dist[i][j]=MAX;
		}
		p=G.vertices[i].firstarc;
		for(;p;p=p->nextarc)
		{
			if(dist[i][p->adjvex]>p->value)
			{
				dist[i][p->adjvex]=p->value;
			}
		}
	}
	for(int k=0;k<G.vexnum;k++)//i->j经过k
	{
		for(int i=0;i<G.vexnum;i++)
		{
			for(int j=0;j<G.vexnum;j++)
			{
				if(i!=j&&i!=k&&j!=k&&dist[i][j]>dist[i][k]+dist[k][j])
				{
					dist[i][j]=dist[i][k]+dist[k][j];
				}
			}
		}
		//输出dist矩阵
		for(int i=0;i<G.vexnum;i++)
		{
			for(int j=0;j<G.vexnum;j++)
			{
				printf("%10d\t",dist[i][j]);
			}
			puts("");
		}
		puts("");
	}
}

int main()
{
	AlGraph G;
	CreateGraph3(G);
	VisitGraph(G);
	//int len=0;
	//FindPath(G,'a','c',len);
	//printf("TopSort=%d\n",TopSort(G));
	//TopSort2(G);
	//printf("IsLoop=%d\n",IsLoop(G));
	int u=1;printf("Prim=%d\n",Prim(G,u));
	printf("Dijkstra=%d\n",Dijkstra(G,u,3));
	Floyd(G);
	CrashAlGraph(G);
	return 0;
}


WayToAccept
关注
专栏目录
图的基础算法 江涛图论数据结构
01-03
图的基础算法 江涛图论数据结构 可用于算法竞赛
数据结构与算法——图(一）
alecsophia的专栏
12-12 728
数据结构与算法——图(mi6236) 图(graph)是一种比线性表、树更为复杂的数据结构。在线性表中，数据元素之间呈线性关系，即每个元素只有一个直接前驱和一个直接后继。在树型结构中，数据元素之间有明显的的层次关系，即每个结点只有一个直接前驱，但可有多个直接后继，而在图结构中，每个结点即可有多个直接前驱，也可有多个直接后继，因此，树结构是图结构的一种特殊情形。当一个树结构中允许同一结
数据结构的基本概念
asd1031的专栏
09-21 878
if you give someone a program,you will frustrate them for a day; if you teach them how to program ,you will frustrate them for a lifetime.(如果你交个某人一个程序，你将折磨他一整天；如果你教给某人如何编写程序，你将折磨他一辈子。)数据结构： 是相互之间存在的一种或
数据结构（一）基本概念
real_ilin的博客
04-20 515
基本概念 数据结构包括数据的存储结构和数据的逻辑结构。 1. 数据的存储结构：顺序结构、链接结构、散列结构和索引结构。 2. 数据的逻辑结构：集合结构、线性结构、树型结构和图型结构。 3. B = (K,R) B代表一种数据结构，R是一种关系，K表示是元素的集合。 4. set、linearity、tree、graph set R为空时，元素之前没有任何关系 linearit...
数据结构－图形数据结构+图的基本概念+单源最短路径
08-12
数据结构－图形数据结构+图的基本概念+单源最短路径
数据结构-图，关于数据结构的逻辑图
12-14
数据结构-图，关于数据结构的逻辑图
山东大学2019年-数据结构-期末试卷真题.pdf
01-27
常见的数据结构包括数组、链表、栈、队列、树、图等。 ### 题目解析与重要知识点 #### 数组(Array) 数组是一种最基本的数据结构，它由相同类型的元素组成，并且这些元素按照一定的顺序排列。数组中的每个元素都...
湖南大学-数据结构-期末试题【2016-2019】.zip
10-25
数据结构是计算机科学中的核心课程，它探讨了如何在计算机中高效地组织和管理数据，以便于进行各种操作。湖南大学的数据结构期末试题涵盖了这门课程的重要概念和技术，旨在检验学生对这些知识的理解和应用能力。以下...
数据结构-图的邻接矩阵表示法
12-13
数据结构-图的邻接矩阵表示法
数据结构——六
最好的时光里
08-20 392
前言：本文为小编在学习数据结构第六章的时候学习记录，话不多说，请看导图：
hdu 5348 MZL's endless loop dfs
uuuuuu
08-05 373
题意：给出一张图确定边的方向，使得每个点的abs(入度-出度) 由于所有点总度数 = m*2，其中除去度数为偶数的点，那么剩下度数为奇数的点个数一定为偶数个，而度数为奇数的点，在一张图中只能为起点或者终点，偶数个这样的点说明了，这张图除去所有环之外（某个环里面的点度数一定是偶数），组成的森林中，一定能组成整数条只包含一个起点一个终点的路径，即假设x个度数为奇数的点，x为偶数，那么可以有x/2条
数据结构总结系列（一）——深度优先遍历之生成森林
weixin_30858241的博客
05-23 1514
最近忙于做数据结构的作业，因此想要总结一下自己在写代码时遇到的一些困难，c++可能不能顺利总结了呜呜呜~ 就从最近的事情开始吧。 【任务描述】 扩充深度优先搜索算法，在遍历图的过程中建立生成森林的左子女-右兄弟链表。 【想法】 首先得出这个结构为一个树的结构，然后思考这个树应该用什么样的结构来存储呢？ 任务里给出答案——链表，当然在图的章节里还有邻接矩阵的数据结构，但拿来存图却...
以指派问题为例写的一个用循环实现dfs的方法.(gcc)
chriselp
02-28 1312
以指派问题为例写的一个用循环实现dfs的方法.(gcc) #include #include #include int main(void) { int n, m; while(~scanf("%d%d",&n, &m)) { int Eft[n][m], i, j; for(i = 0; i < n; ++i) { for(j = 0; j < m; ++j) {
数据结构之图的遍历和部分性质
sinat_36713319的博客
04-06 1536
无向图和有向图 1、无向图中，任意两个顶点之间都存在边的话，就是无向完全图。 　 含有n个顶点的无向完全图有n×(n−1)2\frac{n \times (n-1)}{2}条边。 　 有向图中，若任意两个顶点之间都存在方向互为相反的有向边，则就是有向完全图。 　 含有n个顶点的有向完全图有n×(n−1)n \times (n-1)条有向边。 2、带权的图常称为网。 图的遍历
数据结构基础与基础算法总结
不甩锅的码农
10-29 2351
数据结构基础与基础算法总结，思维导图和总结的资料下载包。包含（1）数据结构基础总结 （2）树型数据结构总结 （3）常用基础算法总结 。
数据结构应试-1
最新发布
Nozomi9967的博客
09-20 705
Head(L)：返回广义表L的第一个元素。Tail(L)：返回除了第一个元素之外的剩余部分组成的广义表。
【数据结构和算法实践-树-LeetCode113-路径总和Ⅱ】
Mao_c的博客
09-14 1046
leetcode b树
数据结构—栈
2301_80151359的博客
09-17 460
/定义栈的结构//栈的空间大小int top;//栈顶}ST;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值