操作系统：作业调度算法--高响应比优先

最新推荐文章于 2024-03-08 09:20:04 发布
最新推荐文章于 2024-03-08 09:20:04 发布
阅读量2.3k 收藏 14
点赞数 3
分类专栏： 课程作业
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52014276/article/details/117198486
版权

3：作业调度算法–高响应比优先
输入N(N>0)个作业，输入每个作业的名字，到达时间，服务时间，按照高响应比优先算法，计算每个作业的完成时间，周转时间，带权周转时间（保留2位小数）。
输入格式:
第一行输入作业数目，第二行输入作业的名字，第三行输入到达时间，第四行输入服务时间。
输出格式:
按照到达时间从小到大排序，第一行输出作业的名字，第二行输出到达时间，第三行输出服务时间，第四行输出完成时间，第五行输出完成时间，第六行输出带权周转时间。
输入样例:
在这里给出一组输入。例如：

5
A B C D E
0 1 2 3 4
4 3 4 2 4

输出样例:
在这里给出相应的输出。例如：

作 业 名：A B C D E
到达时间：0 1 2 3 4
服务时间：4 3 4 2 4
完成时间：4 7 13 9 17
周转时间：4 6 11 6 13
带权周转时间：1.00 2.00 2.75 3.00 3.25

#include<stdio.h>

typedef struct xian{
    char name;
    double dao,service,finish,zhou;
    double daizhou;
    double indexNumber,beforNumber;
    double wait;
    bool flag;
}xian;

void printfXian(xian xians[],int n);
double findMin(int dao[],int index[],int service[],xian xians[],int sum,double beforeFinish);
double findNext(int index[],int dao[],int number,int sum);
double findMax(xian xians[],int index[],int dao[],int service[],double waitSum[],int sum,int indexOne);

int main(){
    int n,i,j;
    int tmp2=10000,tmp3=0;
    scanf("%d", &n);
    getchar();
    xian xians[n];
    int index[n],service[n],dao[n];
    double waitSum[n];
    for(i=0;i<n;i++){
    	xians[i].wait = 0;
        xians[i].flag = true;
        xians[i].finish = 0;
        xians[i].indexNumber = i;
        index[i] = i;
        scanf("%c",&xians[i].name);
        getchar();  //跳过空格
    }
    for(i=0;i<n;i++){
        scanf("%lf",&xians[i].dao);
        dao[i] = xians[i].dao;
        if(xians[i].dao<tmp2){
        	tmp2 = xians[i].dao;
        	tmp3 = i;
		}
    }
    for(i=0;i<n;i++){
        scanf("%lf",&xians[i].service);
        service[i] = xians[i].service;
        xians[i].beforNumber = tmp3;
    }
    
    double tar;
    char tmp;
    int  max,max2;
    
    
    for(i=0;i<n;i++){
         if(i==0){
             xians[tmp3].finish=xians[tmp3].dao+xians[tmp3].service;
             xians[tmp3].zhou=xians[tmp3].finish-xians[tmp3].dao;
             xians[tmp3].daizhou = xians[tmp3].zhou / xians[tmp3].service;    
			 xians[tmp3].flag = false;   
         }else {
         	if(i==1)
             max = findMax(xians,index,dao,service,waitSum,n,tmp3);
           
             if(xians[max].dao<=xians[(int)xians[max].beforNumber].finish)
             xians[max].finish = xians[(int)xians[max].beforNumber].finish + xians[max].service;
             else 
             xians[max].finish = xians[max].dao + xians[max].service;
             xians[max].zhou = xians[max].finish - xians[max].dao;
             xians[max].daizhou = xians[max].zhou / xians[max].service;
             xians[max].flag = false;
       
             max2 = findMax(xians,index,dao,service,waitSum,n,max);
             xians[max2].beforNumber = max;
             max = max2;   
         }
    }
     //对xians数组的到达时间进行从小到大排序==>冒泡排序
    for(i=0;i<n-1;i++){
        for(j=0;j<n-1-i;j++){
            if(xians[j].dao>xians[j+1].dao){
                tmp = xians[j].name;
                xians[j].name = xians[j+1].name;
                xians[j+1].name = tmp;
                
                tar = xians[j].dao;
                xians[j].dao = xians[j+1].dao;
                xians[j+1].dao = tar;
                
                tar = xians[j].service;
                xians[j].service = xians[j+1].service;
                xians[j+1].service = tar;
                
                tar = xians[j].finish;
                xians[j].finish = xians[j+1].finish;
                xians[j+1].finish = tar;
                
                tar = xians[j].zhou;
                xians[j].zhou = xians[j+1].zhou;
                xians[j+1].zhou = tar;
                
                tar = xians[j].daizhou;
                xians[j].daizhou = xians[j+1].daizhou;
                xians[j+1].daizhou = tar;
                
            }
        }
    }
      printfXian(xians,n);
     
    
    return 0;
}

void printfXian(xian xians[],int n){
    int i;
   
    printf("作 业 名：");
    for(i=0;i<n;i++){
        if(i==n-1)
        printf("%c\n",xians[i].name);
        else
        printf("%c ",xians[i].name);
    }
    printf("到达时间：");
    for(i=0;i<n;i++){
        if(i==n-1)
        printf("%.0lf\n",xians[i].dao);
        else
        printf("%.0lf ",xians[i].dao);
    }
    printf("服务时间：");
    for(i=0;i<n;i++){
        if(i==n-1)
        printf("%.0lf\n",xians[i].service);
        else
        printf("%.0lf ",xians[i].service);
    }
    printf("完成时间：");
    for(i=0;i<n;i++){
        if(i==n-1)
        printf("%.0lf\n",xians[i].finish);
        else
        printf("%.0lf ",xians[i].finish);
    }
    printf("周转时间：");
    for(i=0;i<n;i++){
        if(i==n-1)
        printf("%.0lf\n",xians[i].zhou);
        else
        printf("%.0lf ",xians[i].zhou);
    }
    printf("带权周转时间：");
    for(i=0;i<n;i++){
        if(i==n-1)
        printf("%.2lf\n",xians[i].daizhou);
        else
        printf("%.2lf ",xians[i].daizhou);
    }
}

double findMin(int dao[],int index[],int service[],xian xians[],int sum,double beforeFinish){
    int i,j,min;
    double number,tar;
    int n = 1;
    bool flag1 = true;
    while(flag1&&n<=5){
        for(i=0;i<n;i++)
        for(j=0;j<sum-1-i;j++){
            if(service[j]<service[j+1]){
            	number = dao[j];
            	dao[j] = dao[j+1];
            	dao[j+1] = number; 
                number = index[j];
                index[j] = index[j+1];
                index[j+1] = number;
                tar = service[j];
                service[j] = service[j+1];
                service[j+1]= tar;
            }
        }
        min = index[sum-n];

        if(xians[min].dao<=(int)beforeFinish&&xians[min].flag == true&&(int)xians[min].finish == 0){
            flag1 = false;
        }
        else n++;
    }
    if(n==6) min = findNext(index,dao,(int)beforeFinish,sum);
    return min;
}

double findNext(int index[],int dao[],int number,int sum){
	int i,j;
	double number1;
	for(i=0;i<sum-1;i++)
	for(j=0;j<sum-1-i;j++){
		if(dao[j]>dao[j+1]){
			number1 = dao[j];
			dao[j] = dao[j+1];
			dao[j+1] = number1;
			number1 = index[j];
			index[j] = index[j+1];
			index[j+1] = number1;
		}
	} 
	for(i=0;i<sum;i++){
		if(number<dao[i]){
			break;
		}
	}
	return index[i];
}

double findMax(xian xians[],int index[],int dao[],int service[],double waitSum[],int sum,int indexOne){
	
	int i;
	double tmp;
	for(i=0;i<sum;i++){
		if(xians[index[i]].finish == 0&&xians[index[i]].dao<=xians[indexOne].finish){
			waitSum[i] = 1 + (xians[indexOne].finish - xians[index[i]].dao) / xians[index[i]].service*1.0;
		}else if(xians[index[i]].finish == 0&&xians[index[i]].dao>xians[indexOne].finish){
			waitSum[i] = -1;
		}
}
		
	for(i=0;i<sum-1;i++){
		if(waitSum[i]>waitSum[i+1]){
			tmp = waitSum[i];
			waitSum[i] = waitSum[i+1];
			waitSum[i+1] = tmp;
			tmp = index[i];
			index[i] = index[i+1];
			index[i+1] = tmp;
			tmp = dao[i];
			dao[i] = dao[i+1];
			dao[i+1] = tmp;
		}
	}
	if(xians[indexOne].finish<xians[index[sum-1]].dao||indexOne == index[sum-1]||xians[index[sum-1]].flag==false){
		for(i=0;i<sum-1;i++){
			if(waitSum[i]==0||waitSum[i+1]==0) break;
			 else if(dao[i]<dao[i+1]){
				tmp = waitSum[i];
				waitSum[i] = waitSum[i+1];
				waitSum[i+1] = tmp;
				tmp = index[i];
				index[i] = index[i+1];
				index[i+1] = tmp;
				tmp = dao[i];
				dao[i] = dao[i+1];
				dao[i+1] = tmp;
			}
			
		}		
		if(xians[index[i]].flag == false){
		waitSum[i-1] = 0;
		return index[i-1];	
		}
		else{
			waitSum[i] = 0;
		return index[i];
		}
		
	}
	waitSum[sum-1] = 0;
	return index[sum-1];
}
谢三公主
关注
  • 3
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
处理机调度
Junds0的博客
10-20 1837
任务描述 本关任务：编写一个先来先服务器调度算法解决一个实际的进程调度问题，并打印出每个进程的完成时间、周转时间和带权周转时间相关知识 为了完成本关任务，你需要掌握：1.先来先服务调度算法，2.进程周转时间和平均周转时间的计算方法。先来先服务调度算法FCFS FCFS是最简单的调度算法，该算法既可用于作业调度，也可用于进程调度。当在作业调度中采用该算法时，系统将按照作业到达的先后次序来进行调度，或者说它是优先考虑在系统中等待时间最长的作业，周转时间和带权周转时间 周转时间=完成时间-到达时间 带权周转时间
最高响应比算法调度作业.cpp
05-19
《操作系统》第四版，最高响应比算法实现作业调度，作业信息可以自行输入，输出作业号，到达时间，运行时间，完成时间，等等，输出平均周转时间，带权周转时间，调度顺序，
最高响应比优先算法
12-16
本文件是对操作系统作业调度算法中的最高响应比优先算法的设计与实现，代码和报告都放在了压缩文件中，代码使用的文件输入输出。
计算机操作系统 第三章
最新发布
m0_74003766的博客
03-08 908
计算机操作系统（第四版）西安电子科大出版社 复习笔记
高响应比优先调度算法
zuiwuliaopp的专栏
04-24 4126
题目： Input 第一行输入n，表示有n个进程 第二行输入n个进程的名称，数值为单个大写字母表示 第三行输入n个进程的到达时间，数值为正整数，用空格隔开 第四行输入n个进程的运行时间，数值为正整数，用空格隔开 Output 第一行输出n个进程的调度顺序，输出每个进程的名称，用空格隔开 第二行按照调度顺序，输出n个进程的完成时间，结果之间用空格隔开 第三行
图解系统（五）——系统调度算法
weixin_42690036的博客
03-23 772
图解系统（五）——系统调度算法
高响应比优先调度算法(HRRN)
04-30
java平台运行高响应比优先调度算法，如果响应比相同则短作业优先。输出进程工作顺序、调度时间、周转时间、带权周转时间、平均周转时间和平均带权周转时间。压缩带有测试案例
作业调度算法02--短作业优先 (操作系统)
asdbkaj的博客
12-04 6035
作业调度算法02–短作业优先 (操作系统) 输入N（N>0）个作业，输入每个作业的名字，到达时间，服务时间，按照短作业优先算法，计算每个作业的完成时间，周转时间，带权周转时间（保留2位小数）。 输入格式: 第一行输入作业数目，第二行输入作业的名字，第三行输入到达时间，第四行输入服务时间。 输出格式: 按照到达时间从小到大排序，第一行输出作业的名字，第二行输出到达时间，第三行输出服务时间，第四行输出完成时间，第五行输出完成时间，第六行输出带权周转时间。 输入样例: 在这里给出一组输入。例如： 5 A B
【操作系统】题目2：进程调度2-最高响应比优先计算每个作业的周转时间
m0_68259809的博客
02-22 1511
操作系统最高响应比优先计算每个作业的周转时间代码求解。
问题 E: 进程调度2.a--最高响应比优先计算每个作业的完成时间
qq_53227818的博客
11-23 262
程序要求输入3行，以回车符号作为分隔，每行有3个数据，以空格作为分隔。首先输入一个字符串（长度小于等于10），为进程名，第2个数据类型为整型，表示进程的进入时刻，第3个数据类型为整型，表示进程的运行时间。要求输入3个进程的信息，按照最高响应比优先的调度算法计算并输出每个进程的完成时间。(若两个进程的响应比相同，则优先选择运行时间短的进程。若两个进程的响应比相同，而且运行时间也相同，则按照输入的顺序执行。输出三个整数之间，整数之间用空格作为分隔，为每个进程的完成时间。
进程调度模拟-优先级和最高响应比调度算法
01-13
题 目: 进程调度模拟设计——优先级法、最高响应比优先调度算法 初始条件： 1．预备内容：阅读操作系统的处理机管理章节内容，对进程调度的功能以及进程调度算法有深入的理解。 2．实践准备：掌握一种计算机高级语言的使用。 要求完成的主要任务: （包括课程设计工作量及其技术要求，以及说明书撰写等具体要求） 1．模拟进程调度，能够处理以下的情形： ⑴ 能够选择不同的调度算法（要求中给出的调度算法）； ⑵ 能够输入进程的基本信息，如进程名、优先级、到达时间和运行时间等； ⑶ 根据选择的调度算法显示进程调度队列； ⑷ 根据选择的调度算法计算平均周转时间和平均带权周转时间。 2．设计报告内容应说明： ⑴ 课程设计目的与功能； ⑵ 需求分析，数据结构或模块说明(功能与框图)； ⑶ 源程序的主要部分； ⑷ 测试用例，运行结果与运行情况分析； ⑸ 自我评价与总结： i）你认为你完成的设计哪些地方做得比较好或比较出色； ii）什么地方做得不太好，以后如何改正； iii）从本设计得到的收获（在编写，调试，执行过程中的经验和教训）； iv）完成本题是否有其他方法（如果有，简要说明该方法）； v）对实验题的评价和改进意见，请你推荐设计题目。
“短进程优先”、“时间片轮转”、“高响应比优先”调度算法
06-17
编写并调试一个模拟的进程调度程序，分别采用“短进程优先”、“时间片轮转”、“高响应比优先”调度算法对随机产生的五个进程进行调度，并比较算法的平均周转时间。以加深对进程的概念及进程调度算法的理解。
高响应比优先算法.tar.xz
04-14
只考虑1个CPU的资源，其他资源不考虑 使用响应比高者优先算法 程序采用键盘输入，输入格式为： K TJ1 YS1 …… TJK YSK 其中K是作业数（>0），TJi提交时间，YSi （i=1~K）是作业预计的运行时间（以分钟计）TJ的输入格式是XXYY，其中XX是时，YY是分，如10点28分，输入为1028。但内部计算要以60进制来算。要求输出按照作业调度的先后次序输出结果，每行为一个作业状态，从左到右分别是调度次序，作业号，调度时间，周转时间和带权周转时间最后一行输出两个数，第一为平均周转时间，第二为平均带权周转时间。
操作系统-作业调度算法.zip
12-25
操作系统作业调度算法 先来先服务FCFS、短作业优先SIF、最高响应比算法HRRF 输入：作业序列，即一系列要执行的作业，每个作业包括三个数据项：作业号、作业进入系统的时间 按不同的调度算法输出作业序列，进入内存的...
高响应比优先调度算法.c
03-26
动态优先权是指在创建进程时所赋予的优先权，是可以随进程的推进或随其等待时间的增加而改变的，以便获得更好的调度性能。引入动态优先权，并使作业的优先权随其等待时间的增长，...本实验模拟了高响应比优先调度算法。
HRN高响应比优先调度算法的C语言模拟.cpp
07-08
高响应比优先调度算法，通过C语言实现，数据结构用的是链表。操作系统的课程作业，模拟HRN，算法清楚明白，容易看懂，谢谢大家。
Unix时间戳和北京时间的相互转换
woainy的专栏
09-19 1026
一、问题背景 最近项目中需要上传包含时间戳的设备数据到服务器平台。原本想把“年”，“月”，“日”，“时”，“分”， “秒”分别用一个uint8_t的数据类型去存储，即占用6个字节。但是在平台配置协议时，只有一种叫“Unix时间戳”的数据类型。Unix时间戳只占用4个字节，而且Unix时间戳在服务器端更加通用，但是在单片机上没有想Linux环境下现成的time()，localtime()，mktime()等库函数调用。所以考虑自己实现Unix时间戳和北京时间的相互转换。 二、Unix时间戳简介 Unix
进程调度算法中的：先来先服务调度算法、短 进程优先调度算法、时间片轮转调度算法和优先级调度算法（抢占式）、高响应 比优先调度算法的方法设计。
05-28
首先，先来先服务调度算法（FCFS）是一种非抢占式调度算法，根据进程的到达时间依次安排进程执行，即一个进程在CPU占用完毕之前，其他进程无法执行，存在“饥饿”现象。 其次，短进程优先调度算法（SJF）是根据进程的执行时间来安排进程执行的，短进程先执行，长进程后执行，解决了FCFS算法的“饥饿”现象，但是存在“无限期推迟”现象。 第三，时间片轮转调度算法（RR）是抢占式调度算法，根据时间片大小将CPU时间分配给进程，当时间片用完后，将CPU时间分配给下一个进程，避免了长进程占用CPU时间过长的问题。 第四，优先级调度算法（抢占式）是根据进程的优先级来安排进程执行，高优先级的进程先执行，低优先级的进程后执行，可以通过动态调整进程的优先级来保证系统的公平性。 最后，高响应比优先调度算法是根据进程的等待时间和执行时间比值来安排进程执行，等待时间越长的进程，响应比越高，优先执行，避免了长进程占用CPU的问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值