先来先服务FCFS和短作业优先算法SJF

代码原本是参考连胜是我偶像作者的代码,

我本来是用来写实验报告答辩的,图省事,但是copy运行下来发现有一些不太完美的地方,其中的void sjf(struct homework homeworks[50],int n)方法并不能正确的计算出短作业优先进程。

所以,对代码做了一些修改,也欢迎各位同学参考借鉴,对代码出错的地方在评论区留下你宝贵的意见。

#include<stdio.h>
#include<string.h>

struct homework{
	char name[10];    // 进程的名字  
	int arrivetime;   // 进程的到达时间
	int servicetime;   // 进程的服务时间
	int starttime;   // 进程的开始时间
	int overtime;   // 进程的完成时间
	int zz;	//进程的周转时间
	double powertime;  // 进程的带权周转时间
};

// 声明排序方法
void paixu(struct homework homeworks[50],int n);
// 声明进程方法
void process(struct homework homeworks[50],int n);
// 声明先来先服务算法
void fcfs(struct homework homeworks[50],int n);
// 声明短进程优先算法
void sjf(struct homework homeworks[50],int n);
// 声明结果输出方法
void printResult(struct homework homeworks[50],int n);

void main(){
	struct homework homeworks[50];
	int n;  // 定义n个进程
	int i;  // i自变量,用于for语句
	
	// 输入进程的个数
	printf("输入进程个数:");
    scanf("%d",&n);
    printf("输入每个进程的进程名,到达时间,服务时间:\n");

	// 循环为每个进程赋初始值
    for(i=0;i<n;i++)
    {
        scanf("%s",homeworks[i].name); //进程名
        scanf("%d",&homeworks[i].arrivetime);//到达时间
        scanf("%d",&homeworks[i].servicetime);//运行(服务时间)时间
    }
    printf("\n");

	// 显示输入的进程的参数
    printf("进程名\t到达时间\t服务时间\n");
    for(i=0;i<n;i++){
		printf("%s\t      %d\t         %d\n",homeworks[i].name,homeworks[i].arrivetime,homeworks[i].servicetime);
    }

	// 先按到达时间先后进行排序
	paixu(homeworks,n);

	// 先来先服务算法:
    fcfs(homeworks,n);
    printf("先来先服务FCFS:\n");
	process(homeworks,n);
    printResult(homeworks,n);

	// 短作业优先算法
    sjf(homeworks,n);
    printf("短作业优先SJF:\n");
	process(homeworks,n);
    printResult(homeworks,n);
}

// 先来先服务
void fcfs(struct homework homeworks[50],int n)
{
   int i; 
   for(i=0;i<n;i++)
   {
    if(i==0) {      //第一个进程
		homeworks[i].starttime=homeworks[i].arrivetime; //开始时间=到达时间
		homeworks[i].overtime=homeworks[i].arrivetime+homeworks[i].servicetime;//完成时间=到达时间+服务时间  
	    homeworks[i].zz=homeworks[i].overtime - homeworks[i].arrivetime;  // 周转时间 = 完成时间 - 到达时间
    }
    else if(homeworks[i].arrivetime>homeworks[i-1].overtime){ //第i个进程到达系统时,第i-1个进程已运行完毕
		homeworks[i].starttime = homeworks[i].arrivetime;               // 开始时间 = 本进程的到达时间
		homeworks[i].overtime = homeworks[i].arrivetime + homeworks[i].servicetime;   // 完成时间=到达时间 + 服务时间
		homeworks[i].zz=homeworks[i].overtime - homeworks[i].arrivetime;     // 周转时间=完成时间-到达时间
    }
    else{ //第i个进程到达系统时,第i-1个进程未运行完毕
		homeworks[i].starttime = homeworks[i-1].overtime;                      // 开始时间 = 上一个进程的完成时间
		homeworks[i].overtime = homeworks[i].starttime + homeworks[i].servicetime;  // 完成时间=开始时间 + 当前进程的服务时间
		homeworks[i].zz=homeworks[i].overtime-homeworks[i].arrivetime; //周转时间= 完成时间 - 到达时间
       
    }
    homeworks[i].powertime=homeworks[i].zz*1.0/homeworks[i].servicetime;       //带权周转时间=周转时间/服务时间
   }
}

// 短作业优先
void sjf(struct homework homeworks[50],int n)
{
   int i=0,j=0,t=0;  // 用作for循环或者a[]的索引
   int x=0,y=0;  // 临时变量,保存a[]的值
   int a[15]={0}; // 存储各等待进程的i位置,
   char temp[10]; // 临时变量,保存homeworks.name的值
   int time;  // 临时变量,保存homeworks.startime,overtime的值          
        
   
   // 计算第一个进程的开始时间、完成时间、周转、带权周转
   homeworks[0].starttime=homeworks[0].arrivetime;
   homeworks[0].overtime=homeworks[0].arrivetime+homeworks[0].servicetime;//完成时间=到达时间+服务时间
   homeworks[0].zz=homeworks[0].servicetime;//周转时间=服务时间
   homeworks[0].powertime=homeworks[0].zz*1.0/homeworks[0].servicetime;//带权周转时间=周转时间/服务时间

   /* 
		思路:(1)第0个进程正在执行,找出等待的都有哪些进程
			  (2)找出等待的进程中谁是首先运行的
			  (3)待第0进程运行结束后,执行第1个进程,即(2)中找出的进程
			  (4)重复执行(1)-(3),直到进程执行完毕
   */

  // 第0个今晨已经知道,找出谁是第1个执行的进程
   for(j=1;j<n;j++){

		// 找出第0个程序运行时,等待的进程都有哪些,从1→n进程中查找
		for(i=j;i<n;i++){
			if(homeworks[i].arrivetime<=homeworks[j-1].overtime) 
				a[t]=i;        //标记各等待进程的索引
				t++;
		}
		// 比较等待进程的服务时间,for循环执行完毕后即可知道谁是第1个运行的程序
		for(i=0;i<t;i++){
			x = a[i];
			y= a[i+1];
			if(homeworks[x].servicetime > homeworks[y].servicetime&&x!=0&&y!=0){
				// 交换进程名字
				strcpy(temp,homeworks[x].name);             //将第二个参数的值复制给第一个参数,返回第一个参数
				strcpy(homeworks[x].name,homeworks[y].name);
				strcpy(homeworks[y].name,temp);
				// 交换到达时间
				time=homeworks[x].arrivetime;
				homeworks[x].arrivetime=homeworks[y].arrivetime;
				homeworks[y].arrivetime=time;
          
				// 交换服务时间
				time=homeworks[x].servicetime;
				homeworks[x].servicetime=homeworks[y].servicetime;
				homeworks[y].servicetime=time;
			}
		}

		// 排完序之后,计算第1个进程的参数
		if(homeworks[j].arrivetime>homeworks[j-1].overtime)//第i个进程到达系统时,第i-1个进程已运行完毕
		{   
			homeworks[j].starttime = homeworks[j].arrivetime; // 开始时间= 到达时间
			homeworks[j].overtime=homeworks[j].arrivetime+homeworks[i].servicetime; //完成时间=到达时间+服务时间
			homeworks[j].zz=homeworks[j].overtime - homeworks[j].arrivetime;//周转时间=完成时间-到达时间
		}
		else  //第i个进程到达系统时,第i-1个进程未执行完毕
		{
			homeworks[j].starttime= homeworks[j-1].overtime;
			homeworks[j].overtime=homeworks[j].starttime+homeworks[j].servicetime;
			homeworks[j].zz=homeworks[j].overtime-homeworks[j].arrivetime; 
		}
		homeworks[j].powertime=homeworks[j].zz*1.0/homeworks[j].servicetime;  
	}
   // 以此类推
}

// 进程简单输出
void process(struct homework homeworks[50],int n){
	int i;
	for(i=0;i<n;i++){
		if(i!=n-1)
			printf("进程%s→",homeworks[i].name);
		else
			printf("进程%s\n",homeworks[i].name);
	}
}

// 输出算法结果
void printResult(struct homework homeworks[50],int n)
{
    int i;
	// 总周转时间
    int sum_zz=0;
	// 总带权周转时间
    double  sum_powertime=0.00;
	// 平均周转时间
    double averzz;
	// 平均带权周转时间
    double averpowertime;
    printf("进程名\t到达时间\t服务时间\t开始时间\t完成时间\t周转时间  带权周转时间\n");
    for(i=0;i<n;i++)
    {
		printf("%s\t     %d\t       %d\t       %d\t       %d\t      %d            %.2f\n",homeworks[i].name,homeworks[i].arrivetime,homeworks[i].servicetime,homeworks[i].starttime,homeworks[i].overtime,homeworks[i].zz,homeworks[i].powertime);
		// 总周转时间
		sum_zz=sum_zz+homeworks[i].zz;
		// 总带权周转时间
		sum_powertime=sum_powertime+homeworks[i].powertime;
    }
	//计算平均数 
    averzz=sum_zz*1.0/n;
    averpowertime=sum_powertime*1.000/n;
    printf("平均周转时间:%.2f \n",averzz);
    printf("平均带权周转时间:%.3f \n",averpowertime);
    printf("\n");
}

// 按到达时间先后进行排序
void paixu(struct homework homeworks[50],int n){
	int i,j=0;  // 循环变量
	int time;  // “中转”变量,类似于temp
	char temp[10];
	// 将进程按到达时间先后顺序进行排序
	for(i=0;i<n;i++){
		for(j=i+1;j<n;j++)
			if(homeworks[i].arrivetime>homeworks[j].arrivetime)  {   
				// 上下交换进程名
				 strcpy(temp,homeworks[i].name);
				 strcpy(homeworks[i].name,homeworks[j].name);
				 strcpy(homeworks[j].name,temp);//在temp数组中排序

				 //交换到达时间
				 time=homeworks[i].arrivetime;
				 homeworks[i].arrivetime=homeworks[j].arrivetime;
				 homeworks[j].arrivetime=time;

				 //交换服务时间
				  time=homeworks[i].servicetime;
				  homeworks[i].servicetime=homeworks[j].servicetime;
				  homeworks[j].servicetime=time;
			}
}
}

运行结果如图所示:

 先来先服务算法FCFS:

 最短作业优先算法SJF:

经过不是很细心的检验,各进程之间的运行顺序没有毛病,有错误的地方各位同学可以在评论区@我,得赶上课去了~ 

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 先来先服务FCFS)进程调度算法是一种简单的调度算法,按照进程到达的先后顺序进行调度。即先到达的进程先执行,后到达的进程后执行。这种算法的优点是简单易懂,缺点是可能会出现长作业等待时间过长的情况。 作业优先SJF)进程调度算法是一种根据进程执行时间来进行调度的算法。即执行时间的进程先执行,执行时间长的进程后执行。这种算法的优点是可以减少长作业等待时间,缺点是可能会出现作业饥饿的情况。 ### 回答2: 进程调度算法计算机操作系统中非常重要的一部分,FCFS先来先服务)和SJF作业优先)是其中比较常见的两种算法。下面将分别对两种算法进行介绍及比较。 FCFS算法先来先服务,即按照进入就绪队列的顺序,先进入队列的进程先被执行。该算法的优点是简单易懂,不需要对进程的属性进行过多的分析。但是,该算法存在一个致命的弊端:无法处理作业和长作业混杂的情况,因为如果遇到一个长作业作业就会被迫等待很长时间,导致系统的响应速度变慢。 SJF算法作业优先,即在就绪队列中,选择最作业先执行。该算法的优点是可以尽可能地提高系统的响应速度,保证作业更快地完成。但是该算法也存在一些缺点:由于进程的执行时间不确定,因此难以做出一个准确的预测,如果预测错误,可能会出现长时间的等待,导致系统效率降低。 两种算法的比较:FCFS算法最大的优点是简单易懂,没有太多的计算复杂度,但是对于作业和长作业混杂的情况,无法满足系统性能的要求。而SJF算法虽然能够提高系统的响应速度,并且对于作业友好,但也存在预测困难的问题,也会产生等待的情况。因此,需要根据具体的情况选择适合的算法,如果作业的执行时间能够事先预测,SJF算法是一个很好的选择,否则则可以选择FCFS算法。但是在实际应用中,为了更好地提高系统的性能,一般会采用优先级调度算法,根据进程的属性进行优先级的排序,以此来保证更加合理的进程调度顺序。同时,还可以采用时间片轮转的方法,将长作业进行切割,让多个进程共享CPU,提高系统的处理能力。 ### 回答3: 先来先服务FCFS)是一种最简单的调度算法,也被称为先到先服务或先进先出。该算法的基本原理是按照进程到达的顺序进行调度,即先到来的进程先执行,后到达的进程后执行。FCFS算法适用于进程执行时间相同时,优先级相同的情况。由于该算法的简单性,一般只有在任务队列中的进程个数固定且任务时间相等时才使用。但是,FCFS算法的显著缺陷是无法解决作业等待长作业的问题,因此在实际应用中,FCFS算法很少使用。 作业优先SJF)是一种比FCFS算法更为高效的调度算法,也被称为最作业优先。该算法的基本原理是按照进程需要执行的时间的长来进行调度,即先优先选择需要执行时间的进程,而不是按照它们到达的顺序来进行调度。SJF算法适用于任务队列中的进程的时间不一致的情况。该算法具有高响应度、高效率和低等待时间的优点,能够降低平均等待时间。但是,该算法也存在着一定的问题,如容易出现饥饿现象(即在系统运行的过程中,某些进程始终无法被调度执行)。因此,通常可以将作业优先算法与其他调度算法一起使用,以避免饥饿现象的出现。 总之,先来先服务作业优先都是进程调度算法中常见的两种,它们各有优缺点,需要根据具体的情况选择合适的算法来保证系统的效率和稳定性。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值