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

最新推荐文章于 2022-11-11 15:45:29 发布
最新推荐文章于 2022-11-11 15:45:29 发布
阅读量3.2k 收藏 62
点赞数 14
分类专栏： C语言数据结构 文章标签： 数据结构 c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44630656/article/details/103499451
版权

图的分类与构造

图可分为有向图（DG）、有向网（DN）、无向图（UDG）、无向网（UDN）

邻接矩阵的存储结构

//邻接矩阵
typedef struct{
	ElemType vexs[N]; //存储顶点的一维数组 
	int arcs[N][N]; //存储邻接矩阵的二维数组 
	//对于网的邻接矩阵arcs[i][j] = 无穷大 或 权值（当i = j时也可等于0） 
	int vexnum, arcnum; //图的顶点数和弧数 
}MGraph;

邻接矩阵的方式构造图(无向图为例)

//邻接矩阵构造无向图
int LocateVex(MGraph G, ElemType v)
{//寻找顶点的位置下标
	int i;
	for(i = 0; i<G.vexnum; i++)
	{
		if(v == G.vexs[i])
			return i;		
	}
	return -1; //没有找到该顶点返回-1 
}
void Create_UDN(MGraph &G)
{
	int i, j;
	ElemType v1, v2;
	int a1, a2;
	scanf("%d %d", &G.vexnum, &G.arcnum);//输入顶点数和边数
	//读入顶点信息
	for(i = 0;i<G.vexnum; i++) //输入顶点 
		scanf("%d", &G.vexs[i]);
	//初始化邻接矩阵
	for(i = 0; i<G.vexnum; i++)
	{
		for(j = 0; j<G.vexnum; j++)
		{
			G.arcs[i][j] = 0; //邻接矩阵值为零表示两顶点无关
		}
	}
	//读入弧的信息 
	for(i = 0; i<G.arcnum; i++)
	{
		scanf("%d %d", &v1, &v2);
		a1 = LocateVex(G, v1);
		a2 = LocateVex(G, v2);
		G.arcs[a1][a2] = G.arcs[a2][a1] = 1;
		//对于有向图只用令 G.arcs[a1][a2] = 1
	}
}

图的遍历

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

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

  • 方法一：
int visited[N]; //值为0表示未被访问
int FirstAdjVex(MGraph G, int v)
{//第v个顶点的第一个邻接点,如果没有返回-1
	int i, j;
	for(i = 0; i<G.vexnum; i++)
	{
		if(G.arcs[v][i] == 1)
			return i;
	}
	return -1;
}
int NextAdjVex(MGraph G ,int v, int w)
{//第v个顶点的第二个邻接点
	int i;
	for(i = w+1; i<G.vexnum; i++)
	{
		if(G.arcs[v][i] == 1)
			return i;
	}
	return -1;
}
//邻接矩阵从第v（数组下标）个顶点深度优先搜索
void DFS(MGraph G, int v)
{
	//访问v，并标记
	printf("%d ", G.vexs[v]);
	visited[v] = 1;
	int w;
	//v还有没被访问的邻接点
	w = FirstAdjVex(G, v);
	while(w>=0)
	{
		if(visited[w] == 0)  //如果w未被访问则访问w 
			DFS(G, w);
		w = NextAdjVex(G ,v, w); //再找出v的下一邻接点
	}
}

void DFSTraverse(MGraph G)
{
	int i;
	for(i = 0; i<G.vexnum; i++)
		visited[i] = 0; //对标记数组初始化 
	for(i = 0; i<G.vexnum; i++)
		if(visited[i] == 0) //如果第i个顶点尚未被访，则调用DFS 
			DFS(G, i);
}
  • 方法二
void DFS(MGraph G, int v)
{
	int i;
	printf("%d,",G.vexs[v]);
	visited[v] = 1;
	for(i = 0; i<G.vexnum; i++)
	{
		if(visited[i]==0 && G.arcs[v][i] == 1)
		{
			DFS(G, i);
		}
	}
}

void DFSTraverse(MGraph G)
{
	int i;
	for(i = 0; i<G.vexnum; i++)
		visited[i] = 0; //对标记数组初始化 
	for(i = 0; i<G.vexnum; i++)
		if(visited[i] == 0) //如果第i个顶点尚未被访，则调用DFS 
			DFS(G, i);
}

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

  • 方法一
//邻接矩阵的广度优先搜索（Broadth_First Search） 
void BFSTraverse(MGraph G)
{
	//队列
	int Q[N]; //建立队列
	int front, rear; //建立队头和队尾指针 
	front = rear = 0;
	int i, j;
	int v;
	for(i = 0; i<G.arcnum; i++)
		visited[i] = 0;
	
	for(i = 0; i<G.vexnum; i++)
	{
		if(visited[i] == 0)
		{
			//入队并输出 
			Q[rear++] = i;
			visited[i] = 1;
			printf("%d ", G.vexs[i]); 
			//*************************************有问题
			while(front != rear)
			{
				//出队
				v = Q[front++];
				//将v的邻接顶点入队
				for(j = 0; j<G.vexnum; j++)
					
					if(G.arcs[v][j] == 1 && visited[j]==0)
					{
						Q[rear++] = j;
						visited[j] = 1;
						printf("%d ", G.vexs[j]);
					}		
			}
		}
	}
}
  • 方法二
//邻接矩阵的广度优先搜索（Broadth_First Search） 
void BFSTraverse(MGraph G)
{
	//队列
	int Q[N]; //建立队列
	int front, rear; //建立队头和队尾指针 
	front = rear = 0;
	int i, j;
	int v;
	for(i = 0; i<G.arcnum; i++)
		visited[i] = 0;
	
	for(i = 0; i<G.vexnum; i++)
	{
		if(visited[i] == 0)
		{
			//入队并输出 
			Q[rear++] = i;
			visited[i] = 1;
			printf("%d ", G.vexs[i]); 
			//*************************************有问题 
			
			int v ,w;
			while(front != rear)
			{
				//出队
				v = Q[front++];
				w = FirstAdjVex(G, v);
				while(w>=0)
				{
					if(!visited[w])
					{//入队并输出 
						Q[rear++] = w;
						visited[w] = 1;
						printf("%d ", G.vexs[w]);
					}
					w = NextAdjVex(G , v, w);
				}		
			}
		}
	}
}

图的常见算法

最小生成树

  • 构造连通网的一棵生成树，使得总的代价最少——最小生成树的问题。
一、普利姆算法（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) 
void MiniTree_Prim(MGraph G, ElemType v)
{//从第v个顶点出发
	struct{
		int lowcost; //当值为0时则在最小生成树中
		ElemType vex; //closege[i].vex,第i个顶点最小边的另一个顶点 
	}closege[N];
	
	int i, j, k;
	int w; //记录顶点的位置 
	w = LocateVex(G, v);
	for(i = 0; i<G.vexnum; i++)
	{
		//初始化closege[]的值
		if(i != w)
			closege[i].lowcost = G.arcs[w][i];
		else
			closege[i].lowcost = 0;
		closege[i].vex = v;
	}
	int t;
	for(i = 1; i<G.vexnum; i++)//再找其余的G.vexnum-1条边 
	{
		int min = 99999;
		//找最小的边，并入U中出
		for(j = 0; j<G.vexnum; j++)
		{
			if(closege[j].lowcost < min && closege[j].lowcost != 0)
			{
				min = closege[j].lowcost;
				t = j;
			}
		}
		printf("%d %d,", closege[t].vex, G.vexs[t]);
		closege[t].lowcost = 0; //顶点并入U后，该顶点的最小边为零
		//更新边
		for(k = 0; k<G.vexnum; k++)
		{
			if(G.arcs[t][k] < closege[k].lowcost)
			{
				closege[k].lowcost = G.arcs[t][k];
				closege[k].vex = G.vexs[t];
			}	
		}
	}
}
二、克鲁斯卡尔算法（Kruskal）

算法思想：

  1. 设T=(V,{E})是一个连通图,则令最小生成树的初始状态为只有n个顶点而无边的非连通图 ，即:T=( V,{ } ) 图中每个顶点自成一个连通分量。
  2. 在E中选择代价最小的边。约束条件：若此边依附的顶点落在T的不同连通分量上，将此边加入T中。否则舍去此边另选下一条代价最小的边。
  3. 依次类推，直到T中所有顶点都在同一个连通分量中。
AOV-网和AOE-网
  • AOE-网：是边表示活动的有向无环图。顶点表示事件，弧表示活动，权值表示活动持续的时间。 通常，AOE-网可用来估算工程的完成时间。（拓扑排序）
  • AOV-网：用顶点表示活动，用弧表示活动间的优先关系的有向图称为顶点表示活动的网。（关键路径）

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

算法思想：

  • 在有向图中选一个没有前驱的顶点且输出之。
  • 从图中删除此顶点及所有以它为尾的弧。
  • 重复1.2过程，直到所有顶点均已输出，或当前图中不再有无前驱的顶点为止，此种情况表示图中有环。
//拓扑排序(Topological Sort)，也可用来判断回路中是否有环
void TopologicalSort(MGraph G)
{
	//建立入度数组
	int degree[N] = {0};
	int S[N]; //建立一个栈来存放入度为零的顶点
	int top = 0; //栈顶指针
	int t; //t用来接收出栈元素
	int i, j;
	int n = 0; //记录输出顶点的个数，同时用其判断是否有环 
	for(i = 0; i<G.vexnum;i++)
		for(j = 0; j<G.vexnum;j++)
			degree[i]+=G.arcs[j][i];
	//选择没有前驱的顶点 
	for(i = 0; i<G.vexnum; i++)
		if(degree[i] == 0)
			S[top++] = i;
	while(top != 0)
	{
		//出栈的同时输出元素 
		t = S[--top];
		printf("%d ", G.vexs[t]);
		n++; 
		//进行入度-1，并将入度为0的元素进栈 
		for(i = 0; i<G.vexnum; i++)
		{
			if(G.arcs[t][i] == 1)
			{
				degree[i]--;
				if(degree[i] == 0)
					S[top++] = i;
			}
		}
	}
	if(n<G.vexnum)
		printf("该图中存在回路"); 
}

关键路径问题，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}; //活动ai的最早开始时间 
int vl[N] = {0}; //活动ai的最迟开始时间 
int T[N];
int top1 = -1; //构造存放拓扑序列的顶点栈 
int S[N];
int top2 = -1; //构造存放顶点为零的栈和栈顶指针
Status TopologicalOrder(MGraph G)
{
	int i, j;
	int degree[N] = {0}; //各顶点的入度

	int e; //用来存放出栈元素 
	int count; //记录拓扑序列中有几个点，少于顶点个数则说明拓扑排序失败，等于则成功
	//初始化入度
	for(i = 0; i<G.vexnum; i++)
	{
		for(j = 0; j<G.vexnum; j++)
		{
			if(G.arcs[i][j] > 0 && G.arcs[i][j] < MAX)
				degree[j]++;
		}
	}

	for(i = 0; i<G.vexnum; i++)
	{
		if(degree[i] == 0)
		{
			S[++top2] = i; //入度为零进栈
			T[++top1] = i; //入度为零进栈
			count++;
		}
			
	}
	//当栈不空，出栈求最早发生时间并更新入度
	while(top2 != -1)
	{
		e = S[top2--]; 
		for(i = 0; i<G.vexnum; i++)
		{
			if(G.arcs[e][i] < MAX && G.arcs[e][i] != 0)
			{
				degree[i]--;
				if(degree[i] == 0)
				{
					S[++top2] = i;
					T[++top1] = i;
					count++;
					if(ve[e] + G.arcs[e][i] > ve[i])
						ve[i] = ve[e] + G.arcs[e][i];
				}	
			}
		}
	}
	if(count < G.vexnum)
	{
		return 0;
	}
	return 1;
}
//求出最迟开始时间和关键路径 
Status CtriticalPath(MGraph G)
{
	if(!TopologicalOrder(G))
		return 0;
	int i;
	int e;
	e = T[top1--];
	//初始化顶点的最迟开始时间
	for(i = 0; i<G.vexnum; i++)
		vl[i] = ve[e];
	//栈不空，从T中取出元素,并求出该元素的最迟开始时间 
	while(top1 != -1)
	{	
		for(i = 0; i<G.vexnum; i++)
		{
			if(G.arcs[i][e] > 0 && G.arcs[i][e] < MAX)
			{
				if(vl[e]-G.arcs[i][e] < vl[i])
					vl[i] = vl[e]-G.arcs[i][e];
			}
		}
		e = T[top1--];
	}
	//求出关键路径
	for(i = 0; i<G.vexnum; i++)
		if(ve[i] == vl[i])
			printf("%d %d,", i,ve[i]);	
	return 1;
}

最短路径问题

一、迪杰斯特拉算法(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. 同理，求出接下来的每个最短路径。
void ShortestPath_DIJ(MGraph &G, int v0)
{
	int D[N]; //D[v]表示从源点V0到V当前求得最短路径的长度
	int P[N]; //表示从源点V0到V当前求得最短路径上最后经过的顶点为W。
	int final[N]; //表示顶点V的最短路径已求出完毕。0表示未求出，1表示已求出 
	int i, j ,v;
	
	for(i = 0; i<G.vexnum; i++)
	{
		D[i] = G.arcs[v0][i];
		P[i] = v0;
		final[i] = 0;
	}
	final[v0] = 1;
	D[v0] = 0;
	
	for(i = 1; i<G.vexnum; i++)
	{
		int min = 999999;
		int v;
		for(j = 0; j<G.vexnum; j++)
		{
			if(D[j] < min && final[j] == 0)
			{
				min = D[j];
				v = j;
			}
		}
		final[v] = 1;
		for(j = 0; j<G.vexnum; j++) //更新当前最短路径 
		{
			if(D[j] > G.arcs[v0][v] + G.arcs[v][j])
			{
				D[j] = G.arcs[v0][v] + G.arcs[v][j];
				P[j] = v;
			}
		}
	}
}
一、弗洛伊德算法(Floyd)
  • 目的：求每一对顶点之间的最短路径
//弗洛伊德算法(Floyd) 
void ShortestPath_FLOYD(MGraph G)
{
	int i, j, k;
	int D[N][N]; //D[i][j]表示第i个顶点到第j个顶点最短路径的长度 
	int P[N][N]; //P[i][j]表示第i个顶点到第j个顶点最短路径上所经过的最后顶点 
	//初始化 
	for(i = 0; i<G.vexnum; i++)
	{
		for(j = 0; j<G.vexnum; j++)
		{
			D[i][j] = G.arcs[i][j];
			P[i][j] = i;
		} 
	}
	
	for(i = 0; i<G.vexnum; i++)
	{
		for(j = 0; j<G.vexnum; j++)
		{
			for(k = 0; k<G.vexnum; k++)
			{
				if(D[j][k] > D[j][i] + D[i][k])
				{
					D[j][k] = D[j][i] + D[i][k];
					P[j][k] = i;
				}
			}
		}
	}
}**
青衫白衣98
关注
专栏目录
邻接矩阵存储 - Prim最小生成树算法
lshsgbb2333的博客
12-04 1156
Vertex FindMinDist( MGraph Graph, WeightType dist[] ) { /* 返回未被收录顶点中dist最小者 */ Vertex MinV, V; WeightType MinDist = INFINITY; for (V=0; V<Graph->Nv; V++) { if ( dist[V]!=0 && dist[V]
[图]python实现图的遍历、最小生成树、最短路径
woniu201411的博客
11-13 5816
目录 1、图遍历 2、最小生成树-Prime算法 3、最短路径-Dijkstra算法 图的两种常用的表示方式是邻接矩阵和邻接表。以下以邻接矩阵为例，图的初始化定义： class Graph(): def __init__(self,nodeNum,sides,direction=False): self.nodeNum = nodeNum #顶点 ...
数据结构复习之【图】
mmdev
03-15 577
一、基本术语 图：由有穷、非空点集和边集合组成，简写成G(V,E); Vertex：图中的顶点； 无向图：图中每条边都没有方向； 有向图：图中每条边都有方向； 无向边：边是没有方向的，写为(a,b) 有向边：边是有方向的，写为&lt;a,b&gt; 有向边也成为弧；开始顶点称为弧尾，结束顶点称为弧头； 简单图：不存在指向自己的边、不存在两条重复的边的图； ...
图的遍历（邻接矩阵、邻接链表建图，深搜、广搜遍历，生成最小生成树）
12-16
这是我的课程设计，题为《图的遍历》，包括利用邻接矩阵、邻接链表建图，利用深度优先和广度优先遍历图，以及利用prim和克鲁斯卡尔算法生成最小生成树。里面注解详细！
最小生成树（邻接矩阵存图）
最新发布
qq_62601410的博客
11-11 620
数据结构——最小生成树
采用邻接矩阵实现有向网的存储，建立有向网，并实现单源最短路径
即使没人看我也要写
11-09 2677
源代码： #include #include #define MAX 20 //定义的数组长度的最大值 #define Infinite 11111 //宏定义的极大值，相当于无穷，即两个点间不连通 struct Graph //代表图的结构体 { int ljjz[MAX][MAX]; /
邻接表实现无向图的建立与遍历，最小生成树以及最短路径
10-20
无向图是一种图数据结构，其中每条...总的来说，这个压缩包中的代码实现了一套完整的无向图处理工具，包括了图的构建、遍历以及求解最小生成树和最短路径的关键算法。这对于学习图论和算法设计是非常有价值的实践案例。
图数据结构：遍历、最小生成树与最短路径
"该资源是关于数据结构中图的相关问题，包括图的遍历、最小生成树和最短路径等概念。提供了C++代码实现无向加权图（UDG）的创建。" 在数据结构中，图是一种非常重要的抽象数据类型，用于表示对象之间的关系。图由...
图结构详解：遍历、最小生成树与最短路径
本资源是一份关于数据结构中图结构的PPT，涵盖了图的定义、存储表示、遍历算法、最小生成树、最短路径问题、拓扑排序以及关键路径等多个重要概念。主要语言是C++，并涉及到邻接表和数组表示法。 在数据结构中，图是...
【图的邻接矩阵、邻接表存储结构，深度优先和广度优先搜索遍历以及普里姆算法实现最小生成树可执行程序】
lflcodeplus的博客
12-12 8018
​要求1. 编程实现如下功能： （1）输入有向图的顶点数、边数及各条边的顶点对， 建立用邻接表存储的有向图。 （2）输出有向图的邻接表 （3）对有向图进行深度优先搜索和广度优先搜索遍历，并分别输出其遍历序列。 有向图如下所示： #include<iostream> #include<string.h> #include<iomanip> using namespace std; ​ #define ERROR 0 #define OK 1 #define MVNum 1
图的邻接矩阵存储代码
12-03
图邻接矩阵的存储代码 是我话了一个晚上编写的，足够全面
邻接链表存储的有向图
07-13
1.生成一个100个点，3000条边的有向随机图，任选一点作为源点，计算S到其他节点的距离。（注：图用邻接链表存储） 2.将实验一中的有向图变为DAG图。（从中去掉一些边，不允许用递归） 计算上述DAG图中的最长路径。
数据结构实验-构造图的最小生成树
10-26
一、问题描述 运用Prim算法或Kruskal算法构造图的最小生成树。 输入格式（无向图的邻接矩阵）： 8 10, 0 5, 6, 0 0, 3, 13, 0 二、实验目的 掌握图的存储方法、Prim算法或Kruskal算法。 三、实验内容及要求 1、构造图的存储结构。 2、实现Prim算法或Kruskal算法，求出给定无向图的最小生成树。
基于邻接矩阵存储的图的最小生成树的Prime算法
11-26
基于邻接矩阵存储的图的最小生成树的Prime算法，对学习C++和数据结构很有帮助
图的建立(邻接矩阵)+深度优先遍历+广度优先遍历+Prim算法构造最小生成树(Java语言描述)...
weixin_34302798的博客
11-06 483
主要参考资料：数据结构(C语言版)严蔚敏   ，http://blog.chinaunix.net/uid-25324849-id-2182922.html   代码测试通过。 package 图的建立与实现; import java.util.*; public class MGraph { final int MAXVEX = 100; final int INFINITY ...
第十三周项目五（拓扑排序算法验证）
qq_1562zb的博客
11-24 430
问题及代码： *Copyright(c)2016,烟台大学计算机与控制工程学院 *All right reserved. *文件名称：拓扑排序算法验证.cpp *作者：张冰 *时间：11月24日 *版本号；v1.0 *问题描述： 拓扑排序算法验证 *输入描述：图的邻接矩阵 *程序输出：图的邻接表以及其拓扑序列 / [cpp] v
图的存储结构——邻接矩阵的创建
热门推荐
花开不败
07-06 1万+
邻接矩阵（无向图）
图之关键路径
zhang_kai_的博客
11-23 1万+
图之关键路径
数据结构与算法（C语言） | 图的遍历及最小生成树问题
Shannon
08-19 6738
                                                                                       图的遍历 从图中某个顶点出发系统地访问图中所有顶点，使得每个顶点仅被访问一次，这一过程称作图的遍历。 深度优先搜索 ——连通图的深度优先搜索遍历：从图中某个顶点V0 出发，访问此顶点，然后依次从V0的各个未被访问的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值