图之邻接表（存储结构、图的遍历、最小生成树、关键路径、最短路径）

最新推荐文章于 2023-05-18 17:07:34 发布
最新推荐文章于 2023-05-18 17:07:34 发布
阅读量2.3k 收藏 62
点赞数 7
分类专栏： C语言数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44630656/article/details/103499906
版权

邻接表的存储结构（ADJacency List）

//邻接表（Adjacency List） 
//链表中结点的类型 
typedef struct ArcNode{
	int adjvex; //该弧指向的顶点的位置 
	struct ArcNode *nextarc; //指向下一个弧结点的指针
	InfoType info; //该弧的相关信息的指针 
}ArcNode;
//头结点的类型 
typedef struct VNode{
	ElemType data; //顶点的信息 
	ArcNode *firstarc; //指向第一条依附该顶点的弧的指针 
	int degree; //存放顶点的入度 
}VNode, AdjList[N+1]; //AdjList[0]可以不存放顶点信息 
typedef struct {
	AdjList adjlist; //邻接表 
	int vexnum, arcnum; //图的顶点数和弧数 
}ALGraph;

邻接表的方式构造图（无向图）

//邻接表的方式构造无向图
int LocateVex_AL(ALGraph G, ElemType v)
{ //找到顶点v在邻接表中的位置
	int i;
	for(i = 1; i<=G.vexnum; i++)
	{
		if(v == G.adjlist[i].data)
			return i;
	}
	return -1;
}
void Create_ALGraph(ALGraph &G)
{
	int i, j;
	ElemType v1, v2;
	int a1, a2;
	scanf("%d %d", &G.vexnum, &G.arcnum);//输入顶点数和边数
	//读入顶点信息，同时将顶点下一个指针初始化为空,入度初始化为零 
	for(i = 1;i<=G.vexnum; i++)
	{
		scanf("%d", &G.adjlist[i]);
		G.adjlist[i].firstarc = NULL;
		G.adjlist[i].degree = 0; 
	}	

	//读入边的信息
	for(i = 1; i<=G.arcnum; i++)
	{
		scanf("%d %d", &v1, &v2);
		a1 = LocateVex_AL(G, v1);
		a2 = LocateVex_AL(G, v2);
		
		ArcNode * p;
		p = (ArcNode*)malloc(sizeof(ArcNode)); 
		p->adjvex = a2;
		p->nextarc = G.adjlist[a1].firstarc;
		G.adjlist[a1].firstarc = p;
		G.adjlist[a2].degree++;
		//图为无向图，所以弧要做两次插入 
		ArcNode * q;
		q = (ArcNode*)malloc(sizeof(ArcNode)); 
		q->adjvex = a1;
		q->nextarc = G.adjlist[a2].firstarc;
		G.adjlist[a2].firstarc = q;
		G.adjlist[a1].degree++;
	}
}

图的遍历

一、深度优先遍历(Depth_First Search)

算法思想：
1.从图中某一个顶点v出发，访问此顶点，然后依次从v的未被访问过的邻接顶点出发深度遍历图，直到图中所有与v连通的顶点都被访问过；
2.若此时图中还有顶点未被访问（即非连通图），则另选一个未被访问过的顶点起始点，重复此过程，直到所有顶点都被访问过。

//深度优先搜索
void DFS(ALGraph G, int visited[], int v)
{
	int i;
	int t;
	ArcNode *p;
	p = G.adjlist[v].firstArc;
	printf("%c ", G.adjlist[v].data);
	visited[v] = 1;
	while(p)
	{
		if(visited[p->adjvex] == 0)
			DFS(G, visited, p->adjvex);
		p = p->nextArc;
	}
}

void DFSTravel(ALGraph G)
{
	int i;
	int visited[N]= {0}; //值为1表示该店访问过
	for(i = 0; i<G.vexnum; i++)
	{
		if(visited[i] == 0)
			DFS(G, visited, i);
	}
}

二、广度优先遍历(Broadth_First Search)

//广度优先搜索，类似于树的层次遍历
void BFSTravel(ALGraph G)
{
	//利用队列
	int i;
	int visited[N] = {0};
	int Q[N];
	int rear = 0; //队尾指针 
	int front = 0; //队头指针 
	int t; //用来接收出队元素 
	for(i = 0; i<G.vexnum; i++)
	{
		if(visited[i] == 0)
		{
			printf("%c ", G.adjlist[i].data);
			visited[i] = 1;
			Q[rear++] = i;//进队
			while(rear != front)//队不空 
			{
				t = Q[front++];
				ArcNode *p;
				p = (ArcNode*)malloc(sizeof(ArcNode));
				p = G.adjlist[t].firstArc;
				while(p)
				{
					if(visited[p->adjvex]==0)
					{
						printf("%c ", G.adjlist[p->adjvex].data);
						visited[p->adjvex] = 1;
						Q[rear++] = p->adjvex;
					}
					p = p->nextArc;
				}
			}
		}
	}
}

图的常见算法

最小生成树

  • 构造连通网的一棵生成树，使得总的代价最少——最小生成树的问题。
一、普利姆算法（Prim）

算法思想：

  1. 定义一个辅助结构数组 closege[n]，记录从U 到 V-U 具有最小代价的边。 对每个还没有加入到生成树的顶点vi ∈V-U ， 计算：

    closege[i-1].lowcost = Min{ cost(vi , u) | u∈U  }
closege[i-1].vexs =  { u | 若 cost(vi  , u ) 最小  }

  2. 求 closege[k].lowcost 最小的顶点vk+1，并加入到U中，同时把 边（ vk+1 , closege[k].vexs ）加入到生成树中；

  3. 重复1，2过程。直到 U = V。

//最小生成树 
//普利姆算法（Prim） 
struct {
	int lowcost; //closedge[i].lowcost表示当前与第i个顶点相连的的权值最小的边
	int vex; //closedeg[i].vex表示与第i个顶点相连的顶点的位置 
}closedge[N];
void MiniTree_Prim(ALGraph G, int v) //从第v个顶点开始
{
	int i;
	int j;
	int visited[N]={0}; //0表示未访问，1表示已访问 
	printf("%c\n", G.adjlist[v].data);
	visited[v] = 1;
	//初始化closedge
	for(i = 0; i<=G.vexnum; i++)
	{
		closedge[i].lowcost = MAX;
		closedge[i].vex = v;
	}
	ArcNode *p;
	p = G.adjlist[v].firstArc;
	while(p)
	{
		closedge[p->adjvex].lowcost = p->info;
		p = p->nextArc;
		while(p)
		{
			closedge[p->adjvex].lowcost = p->info;
			p = p->nextArc;
		}
	}
	//找出closedge中最小的边，输出并进行更新
	for(j = 1; j<G.vexnum; j++)
	{
		int min = MAX;
		int t;
		for(i = 0; i<G.vexnum; i++)
		{
			if(closedge[i].lowcost < min && visited[i] == 0)
			{
				min = closedge[i].lowcost;
				t = i;
			}
		}
		printf("%c,%d,%c\n", G.adjlist[t].data,closedge[t].lowcost, G.adjlist[closedge[t].vex].data);
		visited[t] = 1;
		
		//更新 
		p = G.adjlist[t].firstArc;
		while(p)
		{
			if(closedge[p->adjvex].lowcost>p->info)
			{
				closedge[p->adjvex].lowcost = p->info;
				closedge[p->adjvex].vex = t;
			}
			p = p->nextArc;
		}
	}
}
二、克鲁斯卡尔算法（Kruskal）

算法思想：

  1. 设T=(V,{E})是一个连通图,则令最小生成树的初始状态为只有n个顶点而无边的非连通图 ，即:T=( V,{ } ) 图中每个顶点自成一个连通分量。
  2. 在E中选择代价最小的边。约束条件：若此边依附的顶点落在T的不同连通分量上，将此边加入T中。否则舍去此边另选下一条代价最小的边。
  3. 依次类推，直到T中所有顶点都在同一个连通分量中。

拓扑排序(Topological Sort),AOV-网

算法思想：

  • 在有向图中选一个没有前驱的顶点且输出之。
  • 从图中删除此顶点及所有以它为尾的弧。
  • 重复1.2过程，直到所有顶点均已输出，或当前图中不再有无前驱的顶点为止，此种情况表示图中有环。
//拓扑排序 (Topological Sort)
void TopologicalSort(ALGraph G)
{
	//统计每个顶点的入度
	//建立栈，存入每个入度为零的顶点
	//当栈不空，删除入度为零以及以它为尾的弧
	int i,t;
	int indegree[N]={0}; //存放入度的数组
	int S[N];
	int top = 0;
	ArcNode *p;
	int count = 0; //记录输出顶点的个数 
	for(i = 0; i<G.vexnum; i++) //统计入度 
	{
		p = G.adjlist[i].firstArc;
		while(p)
		{
			indegree[p->adjvex]++;
			p = p->nextArc;
		}
	}
	for(i = 0; i<G.vexnum; i++) //对入度为零的顶点进栈并访问 
	{
		if(indegree[i] == 0)
		{
			S[top++] = i;
			count++; 
			printf("%c,", G.adjlist[i].data);
		}
	}
	
	while(top != 0) //当栈不空 
	{
		t = S[--top];
		//进行更新
		p = G.adjlist[t].firstArc;
		while(p)
		{
			indegree[p->adjvex]--;
			if(indegree[p->adjvex] == 0)
			{
				S[top++] = p->adjvex; //进栈的同时标记已访问
				count++;
				printf("%c,", G.adjlist[p->adjvex].data);
			}
			p = p->nextArc;
		}
	}
	if(count == G.vexnum)
		printf("\n该图中无回路");
}

关键路径问题，AOE-网

  • 从开始点到完成点的最长路径的长度.即路径上各活动持续时间之和

算法思想：

  1. 输入e条弧，建立AOE-网的存储结构；
  2. 从源点V0出发，令ve[0]=0；按拓扑有序求其余各顶点的ve[i]；若得到的序列中顶点的个数小于网中的顶点总数，则不能求关键路径，算法终止；否则执行步骤(3)；
  3. 从汇点Vn出发，令vL[n-1]=ve[n-1]，按逆拓扑有序求其余各顶点的vL[i]；
  4. 根据各顶点的ve和vL，求每条弧s的e[s]和L[s]，若满足e[s]=L[s]，则为关键活动。
int ve[N] = {0}; //ve[i]表示最早开始时间
int vl[N] = {0}; //vl[i]表示最晚开始时间
int T[N],S[N];
int topS = 0;
int topT = 0;
void TopologicalOrder(ALGraph G)
{
	int i, t;
	int indegree[N] = {0}; 
	ArcNode *p;
	
	for(i = 0; i<G.vexnum; i++) //统计入度 
	{
		p = G.adjlist[i].firstArc;
		while(p)
		{
			indegree[p->adjvex]++;
			p = p->nextArc;
		}
	}
	for(i = 0; i<G.vexnum; i++) //对入度为零的顶点进栈 
	{
		if(indegree[i] == 0)
		{
			S[topS++] = i;
			T[topT++] = i;
		}
	}
	
	while(topS != 0) //当栈不空 
	{
		t = S[--topS];
		p = G.adjlist[t].firstArc;
		while(p) //求出当前最早开始时间，并对入度进行更新 
		{
			if(ve[t] + p->info > ve[p->adjvex])
				ve[p->adjvex] = ve[t]+p->info;
			indegree[p->adjvex]--;
			if(indegree[p->adjvex] == 0)
			{
				S[topS++] = p->adjvex;
				T[topT++] = p->adjvex;
			}
			p = p->nextArc;
		}
	}
}

void CriticalPath(ALGraph G)
{
	int i,t;
	ArcNode *p;
	TopologicalOrder(G);
	t = T[--topT];
	for(i = 0; i<G.vexnum ;i++)
	{
		vl[i] = ve[t];
	}
	
	while(topT != 0)
	{
		t = T[--topT];
		p = G.adjlist[t].firstArc;
		while(p)
		{
			if(vl[p->adjvex]-p->info < vl[t])
				vl[t] = vl[p->adjvex]-p->info;
			p = p->nextArc;
		}
	}
	
	for(i = 0; i<G.vexnum; i++)
	{
		if(ve[i] == vl[i])
			printf("%c,", G.adjlist[i].data);
	}
}

最短路径问题

一、迪杰斯特拉算法(Dijkstra)
  • 目的：求源点到其余各顶点的最短路径

算法思想：

  1. 1.定义D[i]：表示当前所找到的从源点V0到Vi的最短路径的长度。初态：D[i] = G.arcs[v0][vi] 即弧<v , vi>的权值。
  2. D[j] = Min( D[i] ) (i=1,…., n-1)。显然：Vj 就是从V0出发最早到达的长度最短的顶点。
  3. 下一条最短路径为 D[k] = min(D[k] , D[j]+G.arcs[j][k]);
  4. 同理，求出接下来的每个最短路径。
//迪杰斯特拉算法（Dijkstra），求v0到各顶点的最短距离 
void ShortestPath_DIJ(ALGraph G, int v0)
{
	//从v0求直接到其他顶点的距离，其中最小的为最短距离
	//再从该点找直接相连的
	int i, j, t;
	int visited[N] = {0};
	int D[N]; //D[i]表示当前v0到第i个顶点的最短距离 
	int P[N] = {0}; //P[i]表示v0到第i个顶点最短路径所经过的上一个顶点 
	ArcNode *p;
	int min;
	for(i = 0; i<G.vexnum; i++)
		D[i] = MAX;
	
	p = G.adjlist[v0].firstArc;
	while(p)
	{
		D[p->adjvex] = p->info;
		P[p->adjvex] = v0;
		p = p->nextArc;
	}
	D[v0] = 0; //v0到v0点的距离为0 
	for(i = 1; i<G.vexnum; i++)
	{
		//找出D[]中的最小值D[t]
		min = MAX;
		for(j = 0; j<G.vexnum; j++)
		{
			if(D[j] < min && visited[j] == 0)
			{
				min = D[j];
				t = j;
			}
		}
		visited[t] = 1;
		p = G.adjlist[t].firstArc;
		while(p)
		{
			if(D[t] + p->info < D[p->adjvex] && visited[p->adjvex] == 0)
			{
				D[p->adjvex] = D[t] + p->info;
				P[p->adjvex] = t;
			}
			p = p->nextArc;
		}
	}
	
	for(i = 0; i<G.vexnum; i++)
	{
		printf("%d, %d\n",D[i], P[i]);	
	}
}
一、弗洛伊德算法(Floyd)
  • 目的：求每一对顶点之间的最短路径
//弗洛伊德算法（Floyd），求每一对顶点之间的最短距离 
void ShortestPath_FLOYD(ALGraph G)
{
	int i, j, k;
	int D[N][N]; //D[i][j]表示当前第i个顶点到第j个顶点的最短距离
	int P[N][N] = {0}; //P[i][j]表示第i个顶点到第j个顶点最短路径所经过的上一个顶点
	ArcNode *p;
	//初始化D[][]
	for(i = 0;i<G.vexnum; i++)
	{
		for(j = 0; j<G.vexnum; j++)
			D[i][j] = MAX;
	}
	for(i = 0; i<G.vexnum; i++)
	{
		p = G.adjlist[i].firstArc;
		while(p)
		{
			D[i][p->adjvex] = p->info;
			P[i][p->adjvex] = i;
			p = p->nextArc;
		}
		D[i][i] = 0;
	}
	
	for(i = 0;i<G.vexnum; i++)
	{
		for(j = 0; j<G.vexnum; j++)
		{
			for(k = 0; k<G.vexnum; k++)
			{
				if(D[j][i] + D[i][k] < D[j][k])
				{
					D[j][k] = D[j][i] + D[i][k];
					P[j][k] = i;
				}
			}
		}
	}
	for(i = 0;i<G.vexnum; i++)
	{
		for(j = 0; j<G.vexnum; j++)
		{
			printf("%d, %d\n", D[i][j],P[i][j]);
		}
	}
}
青衫白衣98
关注
  • 7
    点赞
  • 踩
  • 62
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
图的邻接表储存及其遍历[数据结构学习]
Zenny
11-19 4899
好长时间没有写代码(感觉自己更弱了)，今天晚上就把数据结构的链表和邻接表部分实现了（手都生了），第一次写邻接表，觉得还是邻接矩阵好很多，毕竟建表还是挺麻烦的.....顺便把bfs和dfs加了进去，刚学数据结构或者算法入门的可以看看，我是小菜，大神 求别喷......       过两天再把几种排序和查找的时空分析和代码实现总结一下，顺便自己也能学到很多，快要考试了，ACM的步伐就放缓一下下...
图的邻接表存储结构的定义及其遍历
bobopeng
10-25 3414
因为之前的一篇博客图的十字链表存储结构的实现及其遍历是图的邻接表存储结构的延伸，所以这里只是简单的谈一下。 邻接表存储结构的定义： #define MaxVex 20 typedef char VertexType ; // 顶点的类型 typedef int EdgeType ; // 边的类型 typedef struct EdgeNode // 边表结点 { int
数据结构 c++ 图的最短路径问题 (邻接表)
11-20
数据结构 c++ 图的最短路径问题 (邻接表) 数据结构 c++ 图的最短路径问题 (邻接表)
数据结构-图的邻接表的定义与实现
最新发布
m0_61789994的博客
05-18 4459
邻接表是一种基于链表的存储方式，它将每个顶点的所有邻接点存储在一个链表中。具体来说，邻接表由一个顶点数组和一个边链表组成，顶点数组中的每个元素表示一个顶点，边链表中的每个结点表示一条边。// 邻接表中的边结构体int to;// 目标节点int weight;// 权重// 邻接表中的节点结构体int val;// 节点的值// 邻居节点// 图的邻接表结构体// 节点集合i < n;return 0;
6.4-图的储存结构与创建-总结-《数据结构第2版（严蔚敏）》
Tomino的博客
11-18 419
6.4图的存储结构与创建 存储结构 便于判断是否有边 便于计算度 便于增删 利用空间 统计边数 邻接矩阵 √ √ × × × 邻接表 × × √ √ √ 十字链表 √ √ √ √ 邻接多重表 √ √ √ √ 6.4.1 邻接矩阵（Adjacency Matrix） /ə’dʒeɪsənsɪ/ /ˈmeɪtrɪks/ 边edge、aec 顶点vertex 1、存储 #define MAX_INT 32767 //int在32位中能取得的最大值表示∞，64位中为 2,14
图的最小生成树
m0_61433144的博客
01-12 3942
在无向图中, 一条边会在邻接矩阵中存储两次, 对于(u,v)这条边, (u,v)与(v,u)这两条意义相同的边都会存储到邻接矩阵中, 所以我们该如何将这两条边中的一条压入堆中呢?在无向图中, 一条边会在邻接表中存储两次, 对于(u,v)这条边, (u,v)与(v,u)这两条意义相同的边都会存储到邻接表中, 所以我们该如何将这两条边中的一条压入堆中呢?我们可以发现如果图中有较小相等的权值边, 最小生成树可能不唯一, 但是最小生成树上的权值之和是相等的. 上面两种方案的权值之和都是50, 但因为(v。
数据结构——无向图的最小生成树算法(Prim&Kruskal)
zswsx123的博客
04-24 2526
#include<iostream> #include<time.h> #include<Windows.h> #include< queue> using namespace std; #define NUM 100 #pragma warning(disable:4996) typedef struct link { int index; int distance; struct link *next; }*Node, node; typedef s
邻接表实现无向图的建立与遍历，最小生成树以及最短路径
10-20
无向图是一种图数据结构，其中每条...总的来说，这个压缩包中的代码实现了一套完整的无向图处理工具，包括了图的构建、遍历以及求解最小生成树和最短路径的关键算法。这对于学习图论和算法设计是非常有价值的实践案例。
数据结构；最小生成树；最短路径；关键路径
12-08
4、 两种存储结构的转换，如果其中一种存储结构为十字链表或邻接多重表则增加 5、 输出图的深度优先遍历序列或广度优先遍历序列（6、 求图的深度优先或广度优先的生成树（或生成森林）（存储结构为孩子-兄弟链表）...
数据结构-图-最小生成树-最短路径
04-24
邻接矩阵用二维数组存储图中每对顶点之间的关系，而邻接表则通过链表存储每个顶点的邻接顶点，适用于稀疏图（边的数量远小于顶点数量的平方）。 图的遍历是图算法的基础，包括深度优先搜索（DFS）和广度优先搜索...
数据结构求最小生成树、最短路径、关键路径
03-25
对任意给定的图（顶点数不小于20，边数不少于30，图的类型可以是有向图、无向图、有向网、无向网），能够输入图的顶点和边（或弧）的信息，并存储到相应存储结构（邻接矩阵、邻接表、十字链表、邻接多重表，任选其中...
图的存储、基本操作及应用（最小生成树）.zip
07-05
最小生成树(Minimum Spanning Tree, MST)是图的一个子集，包含图中的所有顶点，且边的权重之和最小。MST在许多实际问题中都有应用，例如设计成本最低的网络、构造最短的公路网等。解决最小生成树问题有几种经典算法...
数据结构——图的邻接表存储
m0_52148779的博客
12-20 781
数据结构——图的邻接表存储 功能实现： （1）图的邻接矩阵的储存 （2）深度优先遍历 （3）.广度优先遍历 （4）求结点的度 （5）判断图是否连通 （6）求最小生成树 参考代码 #include <stdio.h> #include <stdlib.h> #define maxvex 20 #define maxInt 32767 #define Maxsize 100 /* run this program using the console pauser or add your
6-1 邻接表存储图的广度优先遍历 （20 分）
12-21 3360
6-1邻接表存储图的广度优先遍历（20 分） 试实现邻接表存储图的广度优先遍历。 函数接口定义： void BFS ( LGraph Graph, Vertex S, void (*Visit)(Vertex) ); 其中LGraph是邻接表存储的图，定义如下： /* 邻接点的定义 */ typedef struct AdjVNode *Ptr...
数据结构课设第八周 6-1
qq_45624337的博客
04-14 250
6-1 邻接矩阵存储图的深度优先遍历 (20分) 试实现邻接矩阵存储图的深度优先遍历。 函数接口定义： void DFS( MGraph Graph, Vertex V, void (*Visit)(Vertex) ); 其中MGraph是邻接矩阵存储的图，定义如下： typedef struct GNode *PtrToGNode; struct GNode{ int Nv; /* ...
OJ 邻接表的相关操作
Eli_Code
05-31 2972
邻接表的相关操作 时间限制: 1 Sec 内存限制: 128 MB 题目描述： 输入一个图，用邻接表存储，并实现一些操作。 拷贝下面的代码，按要求完成其中的FirstAdjVex，NextAdjVex，sort和CreateUDG操作，其他地方不得改动。 //图的邻接表存储表示 #include <iostream> #include <iomanip> using namespace std; #define MVNum 100 //最大顶点数 #defi
基于邻接表存储有向图的深度优先遍历
LBJ170的博客
06-14 3886
基于邻接表存储有向图的深度优先遍历 试编写程序，以邻接表位存储结构实现无向图的广度优先遍历操作。 （1）以图的邻接表表示为存储结构建立有向图。 （2）编写有向图的深度优先遍历函数。 （3）以用户指定的顶点为起点，输出顶点的深度优先访问序列。 （4）在主函数中调用菜单函数调试程序。 代码如下： #include<stdio.h> #include<stdlib.h> #define MAXSIZE 30 typedef struct ArcNode { int adjvex
图之邻接矩阵（存储结构、图的遍历、最小生成树、关键路径、最短路径）
weixin_44630656的博客
12-15 3250
图的分类 图可分为有向图（DG）、有向网（DN）、无向图（UDG）、无向网（UDN） 邻接矩阵的存储结构 //邻接矩阵 typedef struct{ ElemType vexs[N]; //存储顶点的一维数组 int arcs[N][N]; //存储邻接矩阵的二维数组 //对于网的邻接矩阵arcs[i][j] = 无穷大 或 权值（当i = j时也可等于0） int vexnum,...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值