图的基本算法

最新推荐文章于 2022-09-01 22:36:02 发布
最新推荐文章于 2022-09-01 22:36:02 发布
阅读量1k 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 图 最短路径 关键路径 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dzyhenry/article/details/8280998
版权

              整理了一下图的基本算法，包括图的深度优先遍历、广度优先遍历、拓扑排序、三种单源最短路径（Bell-Ford、Dijkstra、有向无回路最短路径算法）、关键路径。

              图的存储结构采用的邻接表。

              这里贴出算法的关键部分，具体的实现已经上传到我的资源上了。

              ”graphOperation.cpp“

                

//图的操作：广度优先遍历、深度优先遍历、拓扑排序、单源最短路径(Bellman-Ford, DAG, Dijkstra)、关键路径
#include "h1.h"
#include "QueueDefinition.h"
#include "StackDefinition.h"

void createGraph(ALGraph *g){ //为了方便，图的顶点名称就用顶点的序号代替

	int i, j,vexNum, arcNum;
	int va, vb, w;
	ArcNode *arc, *tempArc;

	printf("请输入图的顶点数,边数: ");
	scanf("%d%d", &vexNum, &arcNum);

	g->vexNum = vexNum;
	g->arcNum = arcNum;

	for(i=0; i<6; i++){                 //初始化顶点
		g->vertices[i].data = i;
		g->vertices[i].firstArc = NULL;
	}

	printf("请输入每条弧(边)的权值、弧尾和弧头(以空格作为间隔):\n");
	
	for(j=0; j<arcNum; j++){

		scanf("%d%d%d", &w, &va, &vb);
		arc = (ArcNode*)malloc(sizeof(ArcNode));
		arc->weight = w;
		arc->adjvex = vb;
		arc->nextArc = NULL;

		tempArc = g->vertices[va].firstArc;//插入该弧
		g->vertices[va].firstArc = arc;
		arc->nextArc = tempArc;

		printf("Input next arc:\n");
	
	}
}

Boolean visited[MAXSIZE];

void visitGraphNode(ALGraph g, int v){

	printf(" %d ", g.vertices[v].data);
}

void BFSTraverse(ALGraph g, SqQueue *Q,  int v){//从顶点v开始的广度遍历

	int n = g.vexNum;
	int adjVex;
	VNode *vNode;
	ArcNode  *arcNode;

	
	vNode = (VNode *)malloc(sizeof(VNode));
	if(!vNode){
		printf("Memory allocation error!\n");
		exit(OVERFLOW);
	}
	
	EnQueue(Q, g.vertices[v]);

	while(QueueLength(*Q) != 0){

		DeQueue(Q, vNode);
		
		if(!visited[vNode->data]){
			visitGraphNode(g, vNode->data);
			visited[vNode->data] = TRUE;
			arcNode = vNode->firstArc;
			while(arcNode){
				adjVex = arcNode->adjvex;
				EnQueue(Q, g.vertices[adjVex]);
				arcNode = arcNode->nextArc;
			}
		}
	}
	free(vNode);
	ClearQueue(Q);
}

void graphBFSTraverse(ALGraph g, int v){//以顶点v开始的所有顶点的宽度遍历

	int n = g.vexNum;
	int i;
	SqQueue *Q;

	Q = (SqQueue *)malloc(sizeof(SqQueue));
	if(!Q){
		printf("Q initialization error!\n");
		exit(OVERFLOW);
	}
	InitQueue(Q);

	for(i=0; i<n; i++){
		visited[i] = FALSE;
	}

	for(i=v; i<n; i++){
		if(!visited[i]){
			BFSTraverse(g, Q, i);
		}
	}

	for(i=0; i<v; i++){

		if(!visited[i]){
			BFSTraverse(g, Q, i);
		}
	}

	DestroyQueue(Q);
}

void DFSTraverse(ALGraph g, int v){

	visited[v] = TRUE;
	visitGraphNode(g, v);
	ArcNode *arcNode;

	arcNode = g.vertices[v].firstArc;
	while(arcNode){
		if(!visited[arcNode->adjvex]){
			DFSTraverse(g, arcNode->adjvex);
		}
		arcNode = arcNode->nextArc;
	}
}

void graphDFSTraverse(ALGraph g, int v){

	int i;
	int n = g.vexNum;

	for(i=0; i<n; i++){
		visited[i] = FALSE;
	}

	for(i=v; i<n; i++){
		if(!visited[i]){
			DFSTraverse(g, i);
		}
	}

	for(i=0; i<v; i++){
		if(!visited[i]){
			DFSTraverse(g, i);
		}
	}
}

void FindInDegree(ALGraph g, int inDegree[]){

	int i;
	int n = g.vexNum;
	ArcNode *arcNode;

	for(i=0; i<n; i++){
		inDegree[i] = 0;
	}

	for(i=0; i<n; i++){
		arcNode = g.vertices[i].firstArc;
		while(arcNode){
			inDegree[arcNode->adjvex]++;
			arcNode = arcNode->nextArc;
		}
	}
}

Status TopologicalSort(ALGraph g, SqQueue *q){//拓扑排序,将拓扑排序结果保存在队列中

	int inDegree[MAXSIZE];
	int i, k, n;
	int count = 0;
	SqStack *S;
	ArcNode *arcNode;

	n = g.vexNum;

	S = (SqStack*)malloc(sizeof(SqStack));
	if(!S){
		printf("初始化栈失败！\n");
		exit(OVERFLOW);
	}

	FindInDegree(g, inDegree);
	
	InitStack(S);

	for(i=0; i<n; i++){
		if(inDegree[i] == 0){
			Push(S, i);
		}
	}

	while(!StackEmpty(*S)){
		Pop(S, &i);
		EnQueue(q, g.vertices[i]); 
		count++;
		arcNode = g.vertices[i].firstArc;
		
		while(arcNode){
			k = --inDegree[arcNode->adjvex];
			if(k == 0){
				Push(S, arcNode->adjvex);
			}
			arcNode = arcNode->nextArc;
		}
	}

	if(count<g.vexNum){
		DestroyStack(S);
		return ERROR; //有回路
	}
	else{
		DestroyStack(S);
		return OK;
	}
}

void printPath(int s, int n, int k, int path[][MAXSIZE]){//由于在path中存储的路径是逆序的，为了能正序的打印路径，我们这里使用递归方式打印

	k = path[n][k];
	if(k != s){
		printPath(s, n, k, path);
		printf(" %d ", k);
	}
}

void ShortestPath_BellmanFord(ALGraph g, int s){ //无“负权回路”的带权有向图单源最短路径算法

	int n = g.vexNum;
	int i, j, k, u, v;
	ArcNode *arcNode;

	int d[MAXSIZE];//用来描述从源点s到v的最短路径上权值的上界
	int path[MAXSIZE][MAXSIZE];
	for(i=0; i<n; i++){
		d[i] = INFINITY;
		for(j=0; j<n; j++){
			path[i][j] = s;
		}
	}
	d[s] = 0;
	path[s][s] = s;

	for(i=0; i<n-1; i++){  //松弛技术
		for(u=0; u<n; u++){
			arcNode = g.vertices[u].firstArc;
			while(arcNode){
				v = arcNode->adjvex;
				if(d[v] > d[u]+arcNode->weight){
					d[v] = d[u] + arcNode->weight;

					k = path[u][u];
					path[v][u] = k;
					while(k != s){
						
						path[v][k] = path[u][k];
						k = path[u][k];
					}
					path[v][v] = u;
				}
				arcNode = arcNode->nextArc;
			}
		}
	}
	
	for(i=0; i<n; i++){         //打印最短距离和路径
		if(d[i]==INFINITY){
			printf("%d->%d:不可达\n", s, i);
		}
		else{
			printf("%d->%d: %d   ", s, i, d[i]);
			printf("路径为: %d", s);
			printPath(s, i, i, path);
			printf(" %d \n", i);
		}
	}
} //时间复杂度为O(VE)  V:顶点数  E:边数

Status ShortestPath_DAG(ALGraph g, int s){ //对于有向无回路的单源最短路径，我们可以用在更低的时间复杂度内完成

	int n = g.vexNum;
	int i, j, k, u, v;
	ArcNode *arcNode;
	VNode *vNode;
	SqQueue *q;

	vNode = (VNode*)malloc(sizeof(VNode));
	if(!vNode){
		printf("Allocate memory for vNode error!\n");
		exit(OVERFLOW);
	}

	q = (SqQueue*)malloc(sizeof(SqQueue));
	if(!q){
		printf("Allocate memory for queue error!\n");
		exit(OVERFLOW);
	}
	InitQueue(q);

	if(!TopologicalSort(g, q)){
		printf("ERROR!此图有回路，无法使用此算法求最短路径！\n");
		return ERROR;
	}

	int d[MAXSIZE];//用来描述从源点s到v的最短路径上权值的上界
	int path[MAXSIZE][MAXSIZE];
	for(i=0; i<n; i++){
		d[i] = INFINITY;
		for(j=0; j<n; j++){
			path[i][j] = s;
		}
	}
	d[s] = 0;
	path[s][s] = s;

	while(!QueueEmpty(*q)){  //执行松弛技术；在有向无回路图中，松弛技术只执行了|E|次（即边数的次数，采用的是聚集分析技术）
		DeQueue(q, vNode);
		u = vNode->data;
		arcNode = vNode->firstArc;
		while(arcNode){
			v = arcNode->adjvex;
			if(d[v] > d[u] + arcNode->weight){
				d[v] = d[u] + arcNode->weight;
				k = path[u][u];
				path[v][u] = k;
				while(k != s){
					path[v][k] = path[u][k];
					k = path[u][k];
				}
				path[v][v] = u;
			}
			arcNode = arcNode->nextArc;
		}
	}
	DestroyQueue(q);
	free(vNode);

	for(i=0; i<n; i++){         //打印最短距离和路径
		if(d[i]==INFINITY){
			printf("%d->%d:不可达\n", s, i);
		}
		else{
			printf("%d->%d: %d   ", s, i, d[i]);
			printf("路径为: %d", s);
			printPath(s, i, i, path);
			printf(" %d \n", i);
		}
	}

	return OK;
}//时间复杂度为O(V+E) V:顶点数 E:边数

int minimum(int d[], int n){

	int i, k, min;
	min = INFINITY;
	for(i=0; i<n; i++){
		if(d[i] < min){
			min = d[i];
			k = i;
		}
	}

	return k;
}

void ShortestPath_Dijkstra(ALGraph g, int s){ //带“正值”权的图的单源最短路径

	int n = g.vexNum;
	int i, j, k, u, v;
	Boolean final[MAXSIZE];
	ArcNode *arcNode;

	int d[MAXSIZE];//用来描述从源点s到v的最短路径上权值的上界
	int path[MAXSIZE][MAXSIZE];
	for(i=0; i<n; i++){
		d[i] = INFINITY;
		final[i] = FALSE;
		for(j=0; j<n; j++){
			path[i][j] = s;
		}
	}
	d[s] = 0;
	path[s][s] = s;
	final[s] = TRUE;

	arcNode = g.vertices[s].firstArc;  //找到源点的邻接点
	while(arcNode){
		v = arcNode->adjvex;
		d[v] = arcNode->weight;
		path[v][v] = s;
		arcNode = arcNode->nextArc;
	}

	for(i=0; i<n-1; i++){
		u = minimum(d, n);//找到已经获得最短路径的点（贪心性质）
		final[u] = TRUE;
		arcNode = g.vertices[u].firstArc;
		while(arcNode){  //对该结点的邻接点进行松弛操作
			v = arcNode->adjvex;
			if(d[v] > d[u] + arcNode->weight){
				d[v] = d[u] + arcNode->weight;
				k = path[u][u];
				path[v][u] = k;
				while(k != s){
					path[v][k] = path[u][k];
					k = path[u][k];
				}
				path[v][v] = u;
			}
			arcNode = arcNode->nextArc;
		}
	}

	for(i=0; i<n; i++){         //打印最短距离和路径
		if(d[i]==INFINITY){
			printf("%d->%d:不可达\n", s, i);
		}
		else{
			printf("%d->%d: %d   ", s, i, d[i]);
			printf("路径为: %d", s);
			printPath(s, i, i, path);
			printf(" %d \n", i);
		}
	}
}

Status TopologicalOrder(ALGraph g, SqStack *t, int ve[]){//拓扑排序,并返回逆序,为求关键路径做准备

	int inDegree[MAXSIZE];
	int i, k, n, u, v;
	int count = 0;
	SqStack *S;
	ArcNode *arcNode;

	n = g.vexNum;

	S = (SqStack*)malloc(sizeof(SqStack));
	if(!S){
		printf("初始化栈失败！\n");
		exit(OVERFLOW);
	}

	FindInDegree(g, inDegree);
	
	InitStack(S);

	for(i=0; i<n; i++){
		if(inDegree[i] == 0){
			Push(S, i);
		}
		ve[i] = 0;
	}

	while(!StackEmpty(*S)){
		Pop(S, &u);
		Push(t, u); 
		count++;
		arcNode = g.vertices[u].firstArc;
		
		while(arcNode){
			v = arcNode->adjvex;
			if(--inDegree[v] == 0){
				Push(S, v);
			}
			if(ve[v] < ve[u] + arcNode->weight){  //计算每个顶点的最早开始时间
				ve[v] = ve[u] + arcNode->weight;
			}
			arcNode = arcNode->nextArc;
		}
	}

	if(count<g.vexNum){
		DestroyStack(S);
		return ERROR; //有回路
	}
	else{
		DestroyStack(S);
		return OK;
	}
}

Status CriticalPath(ALGraph g){ //求关键路径，即最长路径

	int i, k, u, v, n;
	ArcNode *arcNode;
	SqStack *t;
	int ve[MAXSIZE];  //顶点的最早开始时间
	int vl[MAXSIZE];  //顶点的最迟开始时间

	n = g.vexNum;

	t = (SqStack*)malloc(sizeof(SqStack));
	if(!t){
		printf("Allocate memory for stack error!\n");
		exit(OVERFLOW);
	}

	InitStack(t);
	
	if(!TopologicalOrder(g, t, ve)){
		printf("ERROR！有回路，无法求得关键路径！\n");
		return ERROR;
	}

	for(i=0; i<n; i++){
		vl[i] = ve[n-1];
	}

	while(!StackEmpty(*t)){
		Pop(t, &u);
		arcNode = g.vertices[u].firstArc;
		while(arcNode){
			v = arcNode->adjvex;
			if(vl[u] > vl[v] - arcNode->weight){
				vl[u] = vl[v] - arcNode->weight;
			}
			arcNode = arcNode->nextArc;
		}
	}

	int ee, el;
	for(u=0; u<n; u++){
		arcNode = g.vertices[u].firstArc;
		while(arcNode){
			v = arcNode->adjvex;
			ee = ve[u];
			el = vl[v]- arcNode->weight;
			if(ee == el){
				printf("%d ==> %d\n", u, v);
			}
			arcNode = arcNode->nextArc;
		}
	}
	DestroyStack(t);

	return OK;
}

int main(){

	ALGraph *g;
	
	g = (ALGraph*)malloc(sizeof(ALGraph));
	if(!g){
		printf("Allocate memory for graph error!\n");
		exit(OVERFLOW);
	}

	createGraph(g);

	printf("\n\n****************\n");
	printf("广度优先遍历结果：\n");
	graphBFSTraverse(*g, 0);

	printf("\n\n****************\n");
	printf("深度优先遍历:\n");
	graphDFSTraverse(*g, 0);

	printf("\n\n***************\n");
	printf("拓扑排序：\n");
	SqQueue *q;
	VNode *vNode;
	vNode = (VNode*)malloc(sizeof(VNode));
	if(!vNode){
		printf("Allocate memory for vNode error!\n");
		exit(OVERFLOW);
	}
	q = (SqQueue*)malloc(sizeof(SqQueue));
	if(!q){
		printf("Allocate memory for queue error!\n");
		exit(OVERFLOW);
	}
	InitQueue(q);
	TopologicalSort(*g, q);
	while(!QueueEmpty(*q)){
		DeQueue(q, vNode);
		visitGraphNode(*g, vNode->data);
	}
	free(vNode);
	DestroyQueue(q);
	
	printf("\n\n****************\n");
	printf("最短路径(Bellman-Ford)：\n");
	ShortestPath_BellmanFord(*g, 0);

	printf("\n\n****************\n");
	printf("最短路径(DAG)：\n");
	ShortestPath_DAG(*g, 0);

	printf("\n\n****************\n");
	printf("最短路径(Dijkstra)：\n");
	ShortestPath_DAG(*g, 0);

	printf("\n\n****************\n");
	printf("关键路径：\n");
	CriticalPath(*g);

	free(g);

	return 1;
}


dzyhenry
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
noip基本算法必背
10-14
noip基本算法必背
图像的基本运算
weixin_63896439的博客
05-02 1093
D(p , q) ≥ 0.（当且仅当p = q）;
【数据结构】第六章图：图的基本操作；图的广度优先遍历；图的深度优先遍历
weixin_37706349的博客
12-30 6970
上个月写的笔记了，但是一直拖着，检查了一遍没有错字就发了。有时间仔细整理一下。 6.2.4 图的基本操作 Adjacent(G, x, y) 判断图 G 是否存在边 <x, y> 或 (x, y) Neighbors(G, x) 列出图 G 中与结点 x 邻接的边 InsertVertex(G, x) 在图 G 中插入顶点 x DeleteVertex(G
图的基本运算
lalasonghhh的博客
08-16 1198
图的基本运算 [问题描述] 对给定图，实现图的深度优先遍历和广度优先遍历。 [基本要求] 　　　以邻接表为存储结构，实现连通无向图的深度优先和广度优先遍历。以用户指定的结点为起点，分别输出每种遍历下的结点访问序列。 实验内容 public partial class Form1 : Form { public Form1() { In...
基本的图算法
Ho_mu_ra的博客
05-14 371
注：由于数据结构与算法分析上关于图的表述过于混乱，在此使用算法导论作为教材。由于二者关于细节处可能有所出入，因此对图进行重新学习。 1、图的表示。 对于图G(graph)=(V,E)，有两种方法进行表示。 一、邻接矩阵。 二、邻接链表。 其中，邻接矩阵用于稠密图，即边的条数|E|接近|V|²的情形。而邻接链表通常用于稀疏图，即|E|<<|V|²的情形。在实际的应用中，对于邻接链表的运用远远大于对于邻接矩阵的运用。因此，接下来会对邻接链表进行描述和介绍...
基本图形算法
10-27
计算机图形学中第三章的基本图形生成算法 OPenGL
javascript基本算法汇总
10-22
主要为大家详细介绍了javascript基本算法，包括输出奇偶数控制算法、冒泡排序等，感兴趣的小伙伴们可以参考一下
一些基本算法源码.rar
03-13
一些基本算法源码
图及其常见算法
weixin_45565886的博客
09-01 631
图及其常见算法
图的常见算法
qq_20846769的博客
11-30 1375
一、图结构 图有很多种存储方式，主要有邻接表和邻接矩阵两种。邻接表以点集为单位，邻接矩阵以边集为单位。 //图的大结构 public class Graph { public HashMap<Integer,Node> nodes; //点集 public HashSet<Edge> edges; //边集 public Graph(){ nodes = new HashMap<>(); edges = new HashSet&l
图的基本运算算法（基于邻接表）——C/C++
有人_295的博客
06-29 4089
一、概念 图（Graph）结构是一种非线性的数据结构，图在实际生活中有很多例子，比如交通运输网，地铁网络，社交网络，计算机中的状态执行（自动机）等等都可以抽象成图结构。图结构比树结构复杂的非线性结构。 图结构构成 1.顶点（vertex）：图中的数据元素。 2.边（edge）：图中连接这些顶点的线。 所有的顶点构成一个顶点集合，所有的边构成边的集合，一个完整的图结构就是由顶点集合和边集合组成。图...
关键路径
aobengshen0220的博客
07-12 723
工程中的关键活动和关键路径 #include <iostream> using namespace std; #define MVNum 100 //最大顶点数 #define BDNum MVNum * (MVNum - 1) //最大边数 #define OK 1 #de...
图像处理常用边缘检测算子总结
热门推荐
Augusdi的专栏
06-05 10万+
不同图像灰度不同，边界处一般会有明显的边缘，利用此特征可以分割图像。需要说明的是：边缘和物体间的边界并不等同，边缘指的是图像中像素的值有突变的地方，而物体间的边界指的是现实场景中的存在于物体之间的边界。有可能有边缘的地方并非边界，也有可能边界的地方并无边缘，因为现实世界中的物体是三维的，而图像只具有二维信息，从三维到二维的投影成像不可避免的会丢失一部分信息；另外，成像过程中的光照和噪声也是不可避免
数据结构 JAVA描述（八） 最短路径+拓扑排序+关键路径
此生尽兴
12-31 3219
最短路径迪杰斯特拉算法原文分析思路（理解不了这里就pass掉）：在有向网中，从某一源点到其余各点都有一条最短路径。首先在这些最短路径中，长度最短的必定只有一条弧，且它的权值是从源点出发的所有弧上权的最小值；其次，第二条长度次短的最短路径只可能有两种情况： 从源点出发的一条弧，权值大于已求的最短路径的那条弧，但小于其他的从源点出发的弧的权值 是一条经过已求得最短路径的路径 该算法需要引入辅助数组D，
C语言关键路径实现
ZGUIZ的博客
01-22 8795
在工程中，要估算工程完成最短时间，就是要找到一条从源点到汇点的带权路劲长度最长的路径，成为关键路径。 确定关键路径的四个描述量： 1.      事件vi的最早发生时间ve(i)： 进入世界vi的每一活动都结束，vi才有可发生，所以ve(i)是从源点到vi的最长路径长度。其中v0一般为0. 2.      事件vi的最迟发生时间: 事件vi的发生不得延误vi的每一后继事件的最迟发生时间。
数字水印图像的基本算法
最新发布
05-18
以下是数字水印图像的基本算法： 1. 离散余弦变换（DCT）算法：将原始图像和数字水印图像转换为频域，通过修改频域系数的方法将数字水印图像嵌入到原始图像中。 2. 离散小波变换（DWT）算法：将原始图像和数字水印...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值