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

最新推荐文章于 2023-08-24 22:59:23 发布

青衫白衣98

最新推荐文章于 2023-08-24 22:59:23 发布

阅读量3.2k

点赞数 14

分类专栏： C语言数据结构文章标签：数据结构 c#

本文链接：https://blog.csdn.net/weixin_44630656/article/details/103499451

版权

C语言数据结构专栏收录该内容

12 篇文章 3 订阅

订阅专栏

图的分类与构造

图可分为有向图（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）

算法思想：

定义一个辅助结构数组 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 ) 最小  }
```
求 closege[k].lowcost 最小的顶点vk+1，并加入到U中，同时把边（ vk+1 , closege[k].vexs ）加入到生成树中；
重复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）

算法思想：

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

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

算法思想：

输入e条弧，建立AOE-网的存储结构；
从源点V0出发，令ve[0]=0；按拓扑有序求其余各顶点的ve[i]；若得到的序列中顶点的个数小于网中的顶点总数，则不能求关键路径，算法终止；否则执行步骤(3)；
从汇点Vn出发，令vL[n-1]=ve[n-1]，按逆拓扑有序求其余各顶点的vL[i]；
根据各顶点的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.定义D[i]：表示当前所找到的从源点V0到Vi的最短路径的长度。初态：D[i] = G.arcs[v0][vi] 即弧<v , vi>的权值。
D[j] = Min( D[i] ) (i=1,…., n-1)。显然：Vj 就是从V0出发最早到达的长度最短的顶点。
下一条最短路径为 D[k] = min(D[k] , D[j]+G.arcs[j][k]);
同理，求出接下来的每个最短路径。

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

关注

14
点赞
踩
63

收藏

觉得还不错? 一键收藏
0
评论
图之邻接矩阵（存储结构、图的遍历、最小生成树、关键路径、最短路径）

图的分类图可分为有向图（DG）、有向网（DN）、无向图（UDG）、无向网（UDN）邻接矩阵的存储结构//邻接矩阵typedef struct{ ElemType vexs[N]; //存储顶点的一维数组 int arcs[N][N]; //存储邻接矩阵的二维数组 //对于网的邻接矩阵arcs[i][j] = 无穷大或权值（当i = j时也可等于0） int vexnum,...
复制链接

扫一扫