寻找关键路径（C语言）

最新推荐文章于 2024-06-28 00:01:03 发布
最新推荐文章于 2024-06-28 00:01:03 发布
阅读量1.2k 收藏 18
点赞数 4
分类专栏： C语言 文章标签： 邻接表 图 关键路径 拓扑排序 链式栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuchiang03/article/details/125453256
版权

要求：计算图中的关键路径（输入输出均使用文件的形式来实现）

测验工程图的样例

 1.开始的准备工作如下

#include<stdio.h>
#include<stdlib.h>
typedef struct Edgelink {		//边链表
	int End;
	int value;
	struct Edgelink *next;
} Edge,*Elink;

typedef struct Vertexlink {		//顶点数组
	int Begin;
	int indegree;
	int Earliest;
	int Lastest;
	Elink next;
} Vertex[100];

typedef struct Graph {
	int Vnum;                   //顶点数目
	int Enum;
	Vertex List;
} Graph;

typedef struct SNode *stack;
struct SNode {
	int Data;
	struct SNode *next;
};

int ve[100];
int vl[100];

2.用邻接表来存储项目图

void CreateLink(Graph *T) {								//图的创建
	int temp;
	int i,j=1;
	FILE *fp;
	fp=fopen("007.txt","r");
	fscanf(fp,"%d",&T->Vnum);
	fscanf(fp,"%d",&T->Enum);
	for(i=1; i<=T->Enum; i++) {
		fscanf(fp,"%d",&temp);
		if(i==1||temp!=T->List[j-1].Begin) {
			T->List[j].Begin=temp;
			T->List[j].indegree=0;
			T->List[j].next=NULL;
			j++;
		}
		Elink p,q;
		p=(Edge*)malloc(sizeof(Edge));
		fscanf(fp,"%d",&(p->End));
		fscanf(fp,"%d",&(p->value));
		p->next=NULL;
		if(T->List[j-1].next==NULL)
			T->List[j-1].next=p;
		else {
			q = T->List[j-1].next;
			while(q->next) {
				q=q->next;
			}
			q->next=p;
		}
	}
	T->List[j].Begin=T->Vnum;
	T->List[j].indegree=0;
	T->List[j].next=NULL;
	fclose(fp);
}

3.计算每个节点的入度

void Indegree(Graph *T) {
	Elink p;
	int i=1,j,k;
	k=T->Vnum;
	int indegree[10]= {0};
	for(j=1; j<k; j++) {
		p=T->List[j].next;
		do {
			for(i=1; i<=k; i++) {
				if(i==p->End) {
					indegree[i]++;
				}
			}
			p=p->next;
		} while(p!=NULL);
	}
	for(i=1; i<=k; i++) {
		T->List[i].indegree=indegree[i];
		//printf("%d",indegree[i]);
	}
}

4.链式栈结构的基本书写准备

stack CreateStack() {
	stack S;
	S=(stack)malloc(sizeof(struct SNode));
	S->next=NULL;
	return S;
}

int IsEmpty(stack S) {
	return (S->next==NULL);
}

void Push(stack S,int item) {
	struct SNode *Tmpcell;
	Tmpcell=(struct SNode*)malloc(sizeof(struct SNode));
	Tmpcell->Data=item;
	Tmpcell->next=S->next;
	S->next=Tmpcell;
}

int Pop(stack S) {
	struct SNode *FirstCell;
	int TopElem;
	if(IsEmpty(S)) {
		printf("堆栈空");
		return ;
	} else {
		FirstCell=S->next;
		S->next=FirstCell->next;
		TopElem=FirstCell->Data;
		free(FirstCell);
		return TopElem;
	}
}

5.用栈结构来实现拓扑排序和逆拓扑排序（为求关键路径做准备）

stack TopOrder(Graph *T) {
	int i,j,k,count=0;
	stack S,Q;
	S=CreateStack();
	Q=CreateStack();
	Elink p;
	for(i=1; i<T->Vnum; i++) {
		if(T->List[i].indegree==0) {
			Push(S,i);
		}
	}
	for(i=1; i<=T->Vnum; i++) {
		ve[i]=0;
	}
	while(!IsEmpty(S)) {
		j=Pop(S);
		Push(Q,j);
		++count;
		for(p=T->List[j].next; p; p=p->next) {
			k=p->End;
			if(--T->List[k].indegree==0)
				Push(S,k);
			if(ve[j]+p->value>ve[k])
				ve[k]=ve[j]+p->value;
		}
	}
	if(count<T->Vnum)
		return 0;
	else
		return Q;
}

6.关键路径的求解函数

void CriticalPath(Graph *T) {
	int a,j,k,el,ee,dut;
	char tag;
	Elink p;
	stack Q;
	Q=TopOrder(T);
	vl[1]=0;
	for(a=2; a<=T->Vnum; a++)
		vl[a]=ve[T->Vnum];
	while(!IsEmpty(Q)) {
		j=Pop(Q);
		for(p=T->List[j].next; p; p=p->next) {
			k=p->End;
			dut=p->value;
			if(vl[k]-dut<vl[j])
				vl[j]=vl[k]-dut;
		}
	}
	FILE*fp;
	fp=fopen("0071.txt","w");
	fclose(fp);
	for(j=1; j<=T->Vnum; j++)
		for(p=T->List[j].next; p; p=p->next) {
			k=p->End;
			dut=p->value;
			ee=ve[j];
			el=vl[k]-dut;
			if(ee==el)
				fp=fopen("0071.txt","a");
				fprintf(fp,"v%d",j);
				fclose(fp);
			break;
		}
		fp=fopen("0071.txt","a");
		fprintf(fp,"v%d",j-1);
		fclose(fp);
}

总代码如下

#include<stdio.h>
#include<stdlib.h>
typedef struct Edgelink {		//边链表
	int End;
	int value;
	struct Edgelink *next;
} Edge,*Elink;

typedef struct Vertexlink {		//顶点数组
	int Begin;
	int indegree;
	int Earliest;
	int Lastest;
	Elink next;
} Vertex[100];

typedef struct Graph {
	int Vnum;                   //顶点数目
	int Enum;
	Vertex List;
} Graph;

typedef struct SNode *stack;
struct SNode {
	int Data;
	struct SNode *next;
};

int ve[100];
int vl[100];

void CreateLink(Graph *T) {								//图的创建
	int temp;
	int i,j=1;
	FILE *fp;
	fp=fopen("007.txt","r");
	fscanf(fp,"%d",&T->Vnum);
	fscanf(fp,"%d",&T->Enum);
	for(i=1; i<=T->Enum; i++) {
		fscanf(fp,"%d",&temp);
		if(i==1||temp!=T->List[j-1].Begin) {
			T->List[j].Begin=temp;
			T->List[j].indegree=0;
			T->List[j].next=NULL;
			j++;
		}
		Elink p,q;
		p=(Edge*)malloc(sizeof(Edge));
		fscanf(fp,"%d",&(p->End));
		fscanf(fp,"%d",&(p->value));
		p->next=NULL;
		if(T->List[j-1].next==NULL)
			T->List[j-1].next=p;
		else {
			q = T->List[j-1].next;
			while(q->next) {
				q=q->next;
			}
			q->next=p;
		}
	}
	T->List[j].Begin=T->Vnum;
	T->List[j].indegree=0;
	T->List[j].next=NULL;
	fclose(fp);
}

void Indegree(Graph *T) {
	Elink p;
	int i=1,j,k;
	k=T->Vnum;
	int indegree[10]= {0};
	for(j=1; j<k; j++) {
		p=T->List[j].next;
		do {
			for(i=1; i<=k; i++) {
				if(i==p->End) {
					indegree[i]++;
				}
			}
			p=p->next;
		} while(p!=NULL);
	}
	for(i=1; i<=k; i++) {
		T->List[i].indegree=indegree[i];
		//printf("%d",indegree[i]);
	}
}

stack CreateStack() {
	stack S;
	S=(stack)malloc(sizeof(struct SNode));
	S->next=NULL;
	return S;
}

int IsEmpty(stack S) {
	return (S->next==NULL);
}

void Push(stack S,int item) {
	struct SNode *Tmpcell;
	Tmpcell=(struct SNode*)malloc(sizeof(struct SNode));
	Tmpcell->Data=item;
	Tmpcell->next=S->next;
	S->next=Tmpcell;
}

int Pop(stack S) {
	struct SNode *FirstCell;
	int TopElem;
	if(IsEmpty(S)) {
		printf("堆栈空");
		return ;
	} else {
		FirstCell=S->next;
		S->next=FirstCell->next;
		TopElem=FirstCell->Data;
		free(FirstCell);
		return TopElem;
	}
}

stack TopOrder(Graph *T) {
	int i,j,k,count=0;
	stack S,Q;
	S=CreateStack();
	Q=CreateStack();
	Elink p;
	for(i=1; i<T->Vnum; i++) {
		if(T->List[i].indegree==0) {
			Push(S,i);
		}
	}
	for(i=1; i<=T->Vnum; i++) {
		ve[i]=0;
	}
	while(!IsEmpty(S)) {
		j=Pop(S);
		Push(Q,j);
		++count;
		for(p=T->List[j].next; p; p=p->next) {
			k=p->End;
			if(--T->List[k].indegree==0)
				Push(S,k);
			if(ve[j]+p->value>ve[k])
				ve[k]=ve[j]+p->value;
		}
	}
	if(count<T->Vnum)
		return 0;
	else
		return Q;
}

void CriticalPath(Graph *T) {
	int a,j,k,el,ee,dut;
	char tag;
	Elink p;
	stack Q;
	Q=TopOrder(T);
	vl[1]=0;
	for(a=2; a<=T->Vnum; a++)
		vl[a]=ve[T->Vnum];
	while(!IsEmpty(Q)) {
		j=Pop(Q);
		for(p=T->List[j].next; p; p=p->next) {
			k=p->End;
			dut=p->value;
			if(vl[k]-dut<vl[j])
				vl[j]=vl[k]-dut;
		}
	}
	FILE*fp;
	fp=fopen("0071.txt","w");
	fclose(fp);
	for(j=1; j<=T->Vnum; j++)
		for(p=T->List[j].next; p; p=p->next) {
			k=p->End;
			dut=p->value;
			ee=ve[j];
			el=vl[k]-dut;
			if(ee==el)
				fp=fopen("0071.txt","a");
				fprintf(fp,"v%d",j);
				fclose(fp);
			break;
		}
		fp=fopen("0071.txt","a");
		fprintf(fp,"v%d",j-1);
		fclose(fp);
}
int main() {
	Graph *S;
	S = (Graph*)malloc(sizeof(Graph));
	CreateLink(S);
	Indegree(S);
	CriticalPath(S) ;
	return 0;
}

输入样例

 

输出样例

 

关键路径（C语言实现）
数据结构和算法教程（C语言版）
01-03 960
实际场景中，对于某项工程中的各个任务以及完成它们的先后次序，我们经常用有向无环网（带权的有向无环图）来表示。图 1 有向无环图图 1 就是一张有向无环网，整张网表示一项工程，顶点 V1~V9 表示工程中的各个任务；弧 a1~a11 表示执行各个任务的先后次序，各个弧的权值表示完成各个任务所需要的时间。类似上面这样，当我们用有向无环网描述某项工程时，数据结构中称这样的网结构为 AOE（Activity On Edge）网，网中的顶点称为“事件”，弧称为“活动”，弧对应的权值代表活动持续的时间。
关键路径(完整实例及C语言完整代码实现)
热门推荐
记录博主学到的点滴
08-15 1万+
写在前面：博主是一位普普通通的19届二本大学生，平时最大的爱好就是听听歌，逛逛B站。博主很喜欢的一句话花开堪折直须折，莫待无花空折枝：博主的理解是头一次为人，就应该做自己想做的事，做自己不后悔的事，做自己以后不会留有遗憾的事，做自己觉得有意义的事，不浪费这大好的青春年华。博主写博客目的是记录所学到的知识并方便自己复习，在记录知识的同时获得部分浏览量，得到更多人的认可，满足小小的成就感，同时在写博客的途中结交更多志同道合的朋友，让自己在技术的路上并不孤单。 目录: 1. 2. 3.  &n.
关键路径的算法设计与实现(C语言)
05-15
关键路径的算法设计与实现，c语言，可运行.....
关键路径 --->图
luobo140716的专栏
07-06 1356
AOE网：在一个表示工程的带权有向图中，用顶点表示事件，用有向边表示活动，用边上的权值表示活动的持续事件，这种有向图的边表示活动的网，我们称之为AOE网（Activity on edge Network）。 我们把AOE网中没有入边的顶点称为始点或源点，没有出边的顶点称为终点或汇点。 AOV与AOE网的比较 红线就是关键路径，并且长度为5.5天。 关键路径就是权值加
c语言实现 关键路径
06-29
c语言实现关键路径( #include #include ......)
图关键路径(C语言)
09-06
数据结构C语言版里的图关键路径算法实现，代码里有详细注释
关键路径（C语言）
Lucky Home
05-08 3669
#include <stdio.h> #define max 100 #define mc 10000000 #define false -1 #define ok 1 typedef struct{ //定义图 char vex[max]; int arc[max][max]; int vexnum,arcnum; }AmGraph; int locatedv(AmGraph G,char a) //输入的顶点找到位置 { int i=0; for(i=1;i<=G.vexnu
C语言：关键路径（内附完整代码和思路）.docx
11-01
在本文中，我们将深入探讨C语言中的数据结构和算法，特别是关键路径的寻找。关键路径在工程管理和项目规划中非常重要，因为它能确定一个任务或工程的最短完成时间。在这个问题中，我们使用了图这一数据结构，以及...
寻找关键路径
u013734073的博客
01-31 2043
关键路径 回顾本周开发，觉得一点非常好的地方是从一开始就开始抓关键路径。固定量的关键路径是能够将固定量分配到节点中，这些固定量能够体现在堆高计算中。 整体的方案是垂直化的分成了3个部分，在开发的时候选择了水平的方式进行最短路径的实现，每完成一个方法都确保最短路径进度增加。中途也遇到了mysql的查询效率问题果断延迟决策，添加@todo后跳过非核心问题继续往前，所以本周的收获关键路径抓住，每天都有进...
C语言实现 寻找AOE-网的关键路径
weixin_45883188的博客
08-08 1085
1、在AOE-网中，顶点表示事件，边表示活动 2、存储形式：邻接表 3、实现关键：寻找e[i] = l[i]的活动i 为了达到此目的，我们先求ve、vl(顶点的最早、最晚开始时间) ①求ve：初始化ve数组为0，因为最早开始时间越晚越好，所以初始值设的很小，如果某条边首的最早开始时间小于尾的最早开始时间+权重，那么就更新首的最早开始时间(按照拓扑排序顺序来) ②求vl：初始化vl数组为汇点的最早开始时间，因为最晚开始时间越早越好，所以初始值设的很大,如果某条边尾的最晚开始时间大于尾的最晚开始时间-权重，那么
求最短路径的两种算法（C语言实现）
03-24
在计算机科学中，寻找图中的最短路径是一个常见的问题，特别是在网络路由、地图导航和资源分配等领域。本文将深入探讨两种常用的最短路径算法：Dijkstra算法和Floyd-Warshall算法，并提供C语言实现的概述。 首先，...
关键路径c语言
qq_57065913的博客
08-28 160
#include<stdio.h> #include<stdlib.h> typedef char vertexType; typedef int Weight; #define MAX 5 typedef struct EdgeNode{ //边表节点 vertexType adjvex; Weight weight; struct EdgeNode *next; }EdgeNode; typedef struct VertexNode{ Ed.
关键路径求法 c语言版
05-18
关键路径 拓扑排序 C语言 建立邻接表时 用了2个表 实在有点说不过去 其实计算入读 在建立的时候可以计算出来 没有必要用2个表
数据结构——关键路径（C语言）
swy66的博客
07-18 8149
1.定义 通常把计划、施工过程、生产流程、程序流程等都当成一个工程。工程通常分为若干个 称为“活动”的子工程。完成了这些“活动”，这个工程就可以完成了。通常用 AOE-网来 表示工程。AOE-网是一个带权的有向无环图，其中，顶点表示事件，弧表示活动，权表示活动持续的时间。 对 AOE-网有待研究的问题是：（1）完成整项工程至少需要多少时间？（2）哪些活动 是影响工程进度的关键？ 路径长度最长的路径叫做关键路径。 程序需输出（1）关键活动 （2）关键路径 （3）花费最少时间 2.算法设计 2.1步骤 1.求关
关键路径 C语言实现
LoverJuan的博客
12-05 2266
#include #include #define MaxVertexNum 50 #define false 0 #define true 1 typedef int bool; typedef int Vertex; typedef int WeightType; struct VertexNode;//顶点结构 struct AdjNode;//邻接顶点结构 type
C语言实现关键路径
daqiangdetianxia的博客
05-25 853
大一时学的数据结构。目前大三，整理一下。再回首，准备下一站。 一：实验目的 (1) 通过关键路径求解的，帮助学生熟练掌握图的定点，边的概念及其存储实现。 (2) 掌握图的基本运算，以及利用图解决实际问题的基本方法 二：实验内容 （1）图的存储表示，输入图的定点和图的边，并转换为图的存储结构表示。 （2）求解该图所表示工程的关键路径 三：实验要求 （1）根据实验要求编写程序，主机调试并获得运行结果 （2）撰写实验报告 四: 程序清单、调试和测试结果及分析 #include<stdio.h&g.
关键路径——C语言（代码）
最新发布
2302_80790488的博客
06-28 940
然后我们要来计算事件的最早开始和最晚开始时间，首先要遍历每两个事件之间的活动，得到活动的最大值（计算最早开始时间，因为要考虑事件前驱的所有活动都完成）：
数据结构C语言版-求关键路径(纯C代码)
caradm的博客
11-05 344
原因是因为拓扑排序可以保证我们活动的依赖关系顺序进行计算,即某个结点的前驱一定位于该结点前。
C语言关键路径实现
ZGUIZ的博客
01-22 8898
在工程中，要估算工程完成最短时间，就是要找到一条从源点到汇点的带权路劲长度最长的路径，成为关键路径。 确定关键路径的四个描述量： 1.      事件vi的最早发生时间ve(i)： 进入世界vi的每一活动都结束，vi才有可发生，所以ve(i)是从源点到vi的最长路径长度。其中v0一般为0. 2.      事件vi的最迟发生时间: 事件vi的发生不得延误vi的每一后继事件的最迟发生时间。
关键路径的计算(C语言)
zhan_qian的博客
12-07 1270
#include<stdio.h> #include<stdlib.h> #include<math.h> struct stack{ int *data; int top; int maxSize; }; struct node{ int index; struct node *next; }; struct table{ struct node **body; int tablesize; }; char ch[9]={'a','b'.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值