上数据结构学的一种生产计划图

最新推荐文章于 2020-07-31 14:21:51 发布
最新推荐文章于 2020-07-31 14:21:51 发布
阅读量289 收藏 3
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45696452/article/details/105758401
版权

这个数据结构可以反映项目的开始和完成时间，感觉是数据结构的图的一个比较具体的应用。
后面是完整版代码:

#include <stdio.h>
#include <stdlib.h>

/*作业数据*/ 
typedef struct _data{
	int id;
	char name[20];
	int duration;
	int tes;
	int tef;
	int tls;
	int tlf;
	int crutical;
//	int done;
}data;

/*作业关系*/
typedef struct _relation{
	data *d;
	struct _relation *prev,*next;
}relation;

/*作业*/
typedef struct _task{
	data *d;
	relation *predecessor,*successor;
	struct _task *next,*prev;
}task;

/*项目*/
typedef struct _pert{
	task *head,*tail;
	int tes;  //最早开工时间
	int tlf;  //项目完工时间
	char name[20]; 
	int id;
}pert;

int max(int a,int b){
	return (a>b?a:b);
}

int min(int a,int b){
	return (a<b?a:b);
}

int pert_add_task(pert *p,data *d){
	task *t = (task *)malloc(sizeof(task));
	if(t==NULL){
		return 0;
	}
	t->d=d;
	t->predecessor=NULL;
	t->successor=NULL;
	t->next=NULL;
	t->prev=NULL;
	
	if(p->head==NULL){
		p->head=t;
		p->tail=t;
	}else{
		t->prev=p->tail;
		p->tail->next=t;
		p->tail=t;
	}
	
	return -1;
}

void pert_iterate(pert *p){
	task *t = p->head;
	while(t!=NULL){
		//查找紧前节点
		relation *pr = t->predecessor;
		while(pr!=NULL){
			printf("%d<-",pr->d->id);
			pr=pr->next;
		} 
		
		printf("[%d]",t->d->id);
		
		//查找紧后节点
		relation *sr = t->successor;
		while(sr!=NULL){
			printf("->%d",sr->d->id);
			sr=sr->next; 
		} 
		
		printf("\n");
		t=t->next;
	}
}

task *pert_find_task(pert *p,int id){
	task *t=p->head;
	while(t!=NULL){
		if(t->d->id==id){
			return(t);
		}
		
		t=t->next;
	}
	
	return(NULL);
}

relation *pert_find_predecessor(pert *p,int id,int pid){
	task *t=pert_find_task(p,id);
	if(p==NULL){
		return(NULL);
	}
	
	relation *pr=t->predecessor;
	while(pr!=NULL){
		if(pr->d->id==pid){
			return(pr);
		}
		pr=pr->next;
	}
	
	return(NULL);
}

relation *pert_find_successor(pert *p,int id,int pid){
	task *t=pert_find_task(p,id);
	if(p==NULL){
		return(NULL);
	}
	
	relation *sr=t->successor;
	while(sr!=NULL){
		if(sr->d->id==pid){
			return(sr);
		}
		sr=sr->next;
	}
	
	return(NULL);
}

/*pid-predecessor, sid-successor*/
int pert_add_relation(pert *p,int pid,int sid){
	//查找作业
	task *pt=pert_find_task(p,pid);
	if(pt==NULL){
		printf("\n%d not exists!",pid);
		return(0);
	} 
	
	task *st=pert_find_task(p,sid);	
	if(st==NULL){
		printf("\n%d not exists!",sid);
		return(0);
	}
	
	/*判断是否存在*/
	relation *tr=pert_find_predecessor(p,sid,pid);
	if(tr!=NULL){
		printf("This relation has existed!\n");
		return(0);
	}
	
	tr=pert_find_successor(p,pid,sid);
	if(tr!=NULL){
		printf("This relation has existed!\n");
		return(0);
	}
	
	//增加紧前关系
	relation *pr=(relation *)malloc(sizeof(relation));
	if(pr==NULL){
		return(0);
	}
	pr->d=pt->d;
	pr->next=NULL;
	pr->prev=NULL;
	
	if(st->predecessor==NULL){
		st->predecessor=pr;
	}else{
		st->predecessor->prev=pr;
		pr->next=st->predecessor;
		st->predecessor=pr;
	}
	//增加紧后关系 
	relation *sr=(relation *)malloc(sizeof(relation));
	if(sr==NULL){
		return(0);
	}
	sr->d=st->d;
	sr->next=NULL;
	sr->prev=NULL;
	
	if(pt->successor==NULL){
		pt->successor=sr;
	}else{
		sr->next=pt->successor;
		pt->successor->prev=sr;
		pt->successor=sr;
	}
	
	return(-1);
}

int pert_delete_relation(pert *p,int pid,int sid){
	task *pt=pert_find_task(p,pid);
	if(pt==NULL){
		return(0);
	}
	
	task *st=pert_find_task(p,sid);
	if(st==NULL){
		return(0);
	}
	
	//删除紧后关系
	relation *sr=pt->successor;
	while(sr!=NULL){
		if(sr->d->id==sid){
			if(sr->prev==NULL){
				pt->successor=sr->next;
			}else if(sr->next==NULL){
				sr->prev->next=NULL;
			}else{
				sr->next->prev=sr->prev;
				sr->prev->next=sr->next;
			}
			
			free(sr);
			sr=NULL; 
			break;
		}
		sr=sr->next;
	}
	 
	//删除紧后关系
	relation *pr=st->predecessor;
	while(pr!=NULL){
		if(pr->d->id==pid){
			if(pr->prev==NULL){
				st->predecessor=pr->next;
			}else if(pr->next==NULL){
				pr->prev->next=NULL;
			}else{
				pr->next->prev=pr->prev;
				pr->prev->next=pr->next;
			}
			
			free(pr);
			sr=NULL; 
			break;
		}
		pr=pr->next;
	}
	
	return(-1);
}

int pert_delete_task(pert *p,int id){
	/*1)删除紧前和紧后*/
	task *t=pert_find_task(p,id);
	//删除紧前作业 
	relation *pr=t->predecessor;
	while(pr!=NULL){
		task *pt=pert_find_task(p,pr->d->id);
		pert_delete_relation(p,pt->d->id,id);
		
		pr=t->predecessor;
	}
	
	//删除紧后作业
	relation *sr=t->successor;
	while(sr!=NULL){
		task *st=pert_find_task(p,sr->d->id);
		pert_delete_relation(p,id,st->d->id);
		
		sr=t->successor;
	} 
	
	/*2)删除作业本身*/ 
	t=p->head;
	while(t!=NULL){
		if(t->d->id==id){
			if(p->head->d->id==id&&p->tail->d->id==id){
				p->head=NULL;
				p->tail=NULL;
			}else if(p->head->d->id==id){
				p->head=t->next;
				t->next->prev=NULL;
			}else if(p->tail->d->id==id){
				p->tail=t->prev;
				t->prev->next=NULL;
			}else{
				t->next->prev=t->prev;
				t->prev->next=t->next;
			}
			
			free(t->d);
			free(t);
			break;
		}
		
		t=t->next;
	}
}

/*
1. 阈值问题: tls-tes<d
2. 某些作业它们的开完工时间是事先确定，不能改变 
3. 紧前紧后关系：1)fs=finish-start; 2)ss=start-start; 3)ff=finish-finish; 4)sf=start-finish;
4. finish+delta=start
5. 工厂日历 ：worktime/working-shift 
6. 可视化：pert图，GANTT图 
*/
int pert_schedule(pert *p){
	/*初始化*/ 
	task *t=p->head;
	while(t!=NULL){
		t->d->tef=0;
		t->d->tes=0;
		t->d->tlf=0;
		t->d->tls=0;
		//t->d->done=0;
		
		t=t->next;
	}
	
	/*顺排计划*/
	while(1){
		task *t=p->head;
		int c1=0,c2=0;   //c1表示还未算出的作业数目，c2表示该轮循环算出的作业个数 
		while(t!=NULL){
			if(t->d->tes==0&&t->d->tef==0){
				c1++;
			}
			int done=1;
			int tes=0;
			relation *r=t->predecessor;
			while(r!=NULL){
				if(r->d->tef==0){
					done=0;
					break;
				}
				tes=max(tes,r->d->tef);
				r=r->next;
			}
			if(done==1){
				c2++;
				t->d->tes=tes;
				t->d->tef=tes+t->d->duration;
			}
			t=t->next;
		}
		if(c1==0){
			break;
		}
		//环判断
		if(c1>0&&c2==0){
			printf("存在环!");
			return(0); 
		}
		
	}
	
	/*倒排计划*/
	int maxTef=0;
	t=p->head;
	while(t!=NULL){
		maxTef=max(maxTef,t->d->tef);
		
		t=t->next;
	}
	
	while(1){
		int c1=0,c2=0;
		task *t=p->head;
		while(t!=NULL){
			if(t->d->tlf==0){
				c1++;
			}else{
				t=t->next;
				continue;
			}
			
			//判断该作业的紧前作业是否完成
			int done=1;
			int tlf=maxTef;
			relation *r=t->successor;
			while(r!=NULL){
				if(r->d->tlf==0){
					done=0;
					break;
				}
				tlf=min(tlf,r->d->tls);
				r=r->next;
			}
			
			if(done==1){
				c2++;
				t->d->tlf=tlf;
				t->d->tls=tlf-t->d->duration;
			}
			
			t=t->next;
		}
		
		if(c1==0){
			break;
		}
			
		if(c1>0&&c2==0){
			printf("存在环!");
			return(0);
		}
	}
	
	/*关键作业*/
	t=p->head;
	while(t!=NULL){
		if(t->d->tes==t->d->tls){
			t->d->crutical=1;
		}else{
			t->d->crutical=0;
		}
		t=t->next;
	} 
}


void pert_iterate_time(pert *p){
	task *t=p->head;
	while(t!=NULL){
		printf("%d:\ttes:%d\ttef:%d\ttls:%d\ttlf:%d\tcrutical:%d\n",t->d->id,t->d->tes,t->d->tef,t->d->tls,t->d->tlf,t->d->crutical);
		
		t=t->next;
	}
}


int main(int argc, char *argv[]) {
	pert *p=(pert *)malloc(sizeof(pert));
	if(p==NULL){
		return(0);
	}
	p->id=1;
	p->tes=0;
	p->tlf=0;
	p->head=NULL;
	p->tail=NULL;
	
	int i;
	for(i=1;i<=5;i++){
		data *d=(data *)malloc(sizeof(data));
		d->id=i;
		d->duration=i;
		pert_add_task(p,d);
	}
	pert_add_relation(p,1,2);
	pert_add_relation(p,1,3);
	pert_add_relation(p,2,4);
	pert_add_relation(p,3,4);
	pert_add_relation(p,4,5);
	pert_add_relation(p,4,5);
	
	//pert_schedule(p);
	pert_iterate(p);
	/*
	printf("删除关系2-4:\n");
	pert_delete_relation(p,2,4);
	pert_iterate(p);
	
	printf("删除作业2:\n");
	pert_delete_task(p,2);
	pert_iterate(p);
	*/
	
	printf("计划测试:\n");
	pert_schedule(p);
	pert_iterate_time(p);
}

这个数据结构是我们老师教我们的，还没有在别的书上看到过。在这里写一个博客备忘。

weixin_45696452
关注
PERT图事件、活动、松弛时间与关键路径的相关计算
zhang175gl的博客
01-27 1万+
计划评审技术（Program Evaluation and Review Technique，简称PERT）：采用网络图来描述一个项目的任务网络。不仅可以表达子任务的计划安排，还可以在任务计划执行过程中估计任务完成的情况，分析某些子任务完成情况对全局的影响，找出影响全局的区域和关键子任务。以便及时采取措施，确保整个项目的完成。 优点：给出了每个任务的开始时间 缺点：不能反映任务之间的并行关系 PE...
你说，区块链也是一种数据结构？
kikokingの比特宇宙
12-22 1万+
????1.区块链是什么呢？ ????狭义上说 区块链是一种按照时间顺序，将数据区块以顺序相连的方式组合成的一种链式数据结构，并以密码学方式保证的不可篡改和不可伪造的分布式账本。 ????广义来说 区块链是利用块链式数据结构来验证与存储数据、利用共识算法来生成和更新数据、利用密码学的方式保证数据安全、利用智能合约来编程和操作数据的一种全新的分布式基础架构与计算范式。 好了，想必各位看到这里依旧不太清楚这区块链到底是个啥？那么，我们先从一个故事开始讲起： 从前有个封闭的山村，村民的主要工作就是挖玉
一张图看懂数据结构-——图
老猫的博客
05-08 1万+
最小生成树 Prim算法 图解 一些说明： min_weight数组表示该集合到达剩余顶点的最小值 adjvex表示这个最小权值是由哪个顶点引入 每次选取最小的权值顶点加入后，需要更新min_weight的数值，选取值变为0，全部都为0时表示树已经生成 代码 void MST_Prim(Grap G) { //初始化部分 int min_weight[G.vexnum]; ...
破旧立新破解先有鸡还是先有蛋
weixin_30258027的博客
02-28 97
　　这个世界上是先有鸡还是先有鸡蛋呢？　　这是一个流传极广的难题，往往被认为无法回答，算是一个“看起来很简单，实际上异常困难”的典型。　　先有鸡还是先有蛋之所以无法解答，并非真的有多难，而是因为其中藏着一个逻辑陷阱而已，而这个陷阱就是--循环定义。　　当然先有鸡还是先有蛋本身是没有为最重要的鸡和鸡蛋进行定义的，如果问题本身有进行定义，那么这个逻辑陷阱就太明显了。对于鸡和鸡蛋的定义，其实是...
PERT图的事件、活动、松弛时间、关键路径的理解和计算
热门推荐
如是说的博客
04-28 2万+
介绍 PERT（Program/Project Evaluation and Review Technique）即计划评审技术，PERT是利用网络分析制定计划以及对计划予以评价的技术。 构造PERT图，需要明确四个概念：事件、活动、松弛时间和关键路线。 事件（Events）表示主要活动结束的那一点； 活动（Activities）表示从一个事件到另一个事件之间的过程； 松弛时间（slac...
CSR 消息机制 的常见结构体
小y的博客
06-18 789
CSR Message Types typedef uint16 MessageId; //消息ID 16 Bit typedef uint32 Delay; // 消息延时 32 Bit typedef ...
简析计算机图形学中数据结构的应用 (1).pdf
08-07
首先，数据结构是一种组织数据的方式，它允许程序员以不同的方式存储、操作和访问数据。在计算机图形学中，数据结构使得图形数据组织变得有序，方便计算机生成、处理和输出图形。例如，将图形数据结构化后，可以快速...
行业分类-设备装置-一种书架结构.zip
09-04
在IT行业中，尽管“行业分类-设备装置-一种书架结构.zip”这个标题看似与信息技术的核心内容不直接相关，但我们可以从中引申出一些与IT技术应用和设计思路相关的知识点。书架结构的设计和实现，虽然主要属于工业设计...
行业分类-设备装置-一种结构复合墙板.zip
08-21
总的来说，"行业分类-设备装置-一种结构复合墙板.zip"这个压缩包文件代表了IT技术在建筑行业中的一种具体应用，涵盖了从设计、生产到安装的全过程，体现了数字化和智能化的趋势。通过深入理解和应用其中的知识，可以...
数据结构编程题汇总
11-07
图由节点（顶点）和边组成，是一种更加灵活的数据结构。图可以用来表示各种复杂的关系网络，如社交网络、互联网路由等。根据边是否有方向，图可以分为无向图和有向图。 ### 典型考研编程题目分析 #### 1. 数组反转...
数据结构课的大作业
weixin_45696452的博客
07-31 1541
数据结构课程的大作业，大致要求是利用树做一个WBS模型并在WBS的基础上利用有向图构建计划制定模型。计划制定模型要求能够检查环，能实现顺排和倒排，工作日历要能跳过周末安排任务，要实现根据自定义的delta值实现关键路径的查找。 想着很久也没写过什么了，而且这个代码老师打分了之后也没说对不对，所以分享这个代码也是请大家看看这个代码的不足和改进之处。 这个程序用C语言实现的，代码如下: #include <stdio.h> #include <stdlib.h> /*作业数据*/ ty
线程池初探
六斤的小猪猪呀
04-04 236
线程池初探 一、什么是线程池   线程池是对多线程编程的一种处理方式，其线程都为后台线程。处理过程中将任务添加到整个线程池，线程池挑选线程来处理任务，达到异步解耦的目的。可用于异步、解耦。   线程相关：linuxC/C++多线程 二、线程池的组成   任务队列：存放待处理任务的队列；   执行队列：处理任务的队列，每个队列为一个线程；   管理组件：执行队列对任务队列处理的策略，使线程池合理的运...
关于先有鸡还是先有蛋，终于有正确答案了
web开发自学
05-29 765
关于先有鸡还是先有蛋，终于有正确答案了http://www.cnn.com/2006/TECH/science/05/26/chicken.egg/index.html 根据遗传学，一个生物的基因在它的整个生命周期中是不变得。 因此当年，也就是史前的某一只鸟在繁殖的时候，发生了基因突变。形成了某种早期的鸡的基因。这个受精卵，也就是鸡的雏形，它慢慢变成蛋，然后成为鸡。所以是现有蛋，然后有鸡。...
关键链法vs关键路径法
从菜鸟到菜菜鸟
06-08 2万+
<br />关键链法与关键路径法的区别：<br />1. 关键链法考虑了人的因素和资源约束，这是与网络计划里的关键路径法最大的差别。<br /><br />2. 关键路径法使用的数据是包含安全时间的保守工期；而关键链法使用的数据最可能工期，并把安全时间拿出来集中管理。<br /> <br />3. 关键路径是一次就可以确定的；而关键链是不能一次就确定，是一个循环往复、不断寻优的过程；<br /> <br />4. 关键路径有严格的紧前紧后关系，而关键链没有，但有较复杂的逻辑关系。<br /><br />5.
csr8670--sink工程的大致工作流程分析（以speaker为例）一
Share&Shy的博客
01-14 1万+
今天是14号 15号更新，说明，刚开始看程序有点复杂 没办法，必须看代码 建议首先先把ADK3.5.1中的例程tutorials看完，对学习很有帮助1.csr中的消息机制1.1 adk3.5.1中的led的例子 csr8670中是以消息机制进行任务调度的，根据消息调用相应的回调函数进行处理，如下面这个例子所示：在主函数中，首先设置PIO为输出并且设置为低电平，然后调用了messagesend函
数据结构在线学习平台：JSP与SQL Server实现
- 数据库是一种组织和管理数据的工具，其中关系数据库是最常见的类型，如SQL Server 2000。 - 关系数据库由多个表组成，每个表包含记录和域，通过关系（如外键）连接这些元素。 - SQL Server 2000提供Web支持，...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值