短作业优先调度算法(SJF)

假设有n项作业位于就绪队列中,这些作业的提交时间用数组requestTimes按照提交时间的先后顺序存储,对应的作业服务时间(持续时间)用数组durations存储。采用SJF算法,计算n项作业的平均等待时间。当存在多个相同长度的短作业时,按照提交时间的先后顺序进行调度。假设0<= n <= 100。求出所有作业的平均等待时间。

函数原型:void minWaitingTime(int requestTimes[],int durations[],int n)

测试用例:

输入

4
0 2 4 5
7 4 1 4

输出:

4.0

 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 #include <string.h>
 4
 5 #define MAX 0x7FFFFFFF
 6
 7 void minWaitingTime(int requestTimes[],int durations[],int n)
 8 {
 9     int i,time,j,k;
10     float res;
11     int index,arriveTime,indextemp;
12     int *done = (int *)malloc(sizeof(int) * n);  //表示作业是否执行过,1表示执行完毕,0表示未执行
13     int *wait = (int *)malloc(sizeof(int) * n);  //表示等待时间
14     for(i = 0; i < n; ++i){
15         wait[i] = 0;
16         done[i] = 0;
17     }
18
19     time = 0;  //time表示总作业执行时间
20     for(i = 0; i < n; i++){
21         if(i == 0){  //执行第一个作业
22             time += durations[i];
23             done[i] = 1;
24             for(j = 1; j < n; j++){
25                 if(requestTimes[j] < time)
26                     wait[j] = time - requestTimes[j];
27             }
28         }
29         else{
30             index = GetMin(durations,done,n);
31             //判断是否有多个最短作业,如有选择其中先到达的
32             arriveTime = requestTimes[index];
33             for(indextemp = index + 1; indextemp < n; indextemp++){
34                 if(done[indextemp] == 0 && durations[indextemp] == durations[index] &&
35                     requestTimes[indextemp] < arriveTime)
36                     index = indextemp;
37             }
38
39             time += durations[index];
40             done[index] = 1;
41             //执行选出的最短作业,并更新其它作业的等待时间
42             for(indextemp = 0; indextemp < n && i < n-1; indextemp++)
43                 if(done[indextemp] == 0 &&requestTimes[indextemp] < time)
44                     wait[indextemp] = time - requestTimes[indextemp];
45         }
46     }
47
48     res = 0.0;
49     for(i = 0; i < n; i++)
50         res += wait[i];
51
52     printf("%f\n",res / n);
53
54 }
55 //每次取出服务时间最短且示执行过的作业
56 int GetMin(int durations[],int done[],int n)
57 {
58     int i,j,min = MAX;
59     for(i = 0; i < n; i++)
60         if(durations[i] < min && done[i] == 0){
61             min = durations[i];
62             j = i;
63         }
64     return j;
65 }
66
67 int main()
68 {
69     int requestTimes[100];
70     int durations[100];
71     int i,n;
72     scanf("%d",&n);
73     for(i = 0; i < n; i++)
74         scanf("%d",&requestTimes[i]);
75     for(i = 0; i < n; i++)
76         scanf("%d",&durations[i]);
77
78     minWaitingTime(requestTimes,durations,n);
79
80     system("pause");
81     return 0;
82 }
时间: 2024-10-06 08:18:00

短作业优先调度算法(SJF)的相关文章

模拟处理机作业调度---短作业优先调度算法

短作业优先调度原理 短作业优先调度算法是指对短作业优先调度的算法.短作业优先(SJF)的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业,将它们调入内存运行. 算法流程图 JCB 代表一个作业,JCB 的结构如下: 模拟实现 在屏幕上输出以下作业状态表: 可以通过键盘命令动态地增加作业(即增加一个 JCB 数 据结构项).增加作业后,作业状态表内容可更新查看. 算法代码: #include "stdafx.h" #include<iostream> #inclu

最短作业优先(SJF)

1. 最短作业优先: 最短作业优先(SJF)是一种调度任务请求的调度策略.每个任务请求包含有请求时间(即向系统提交的请求的时间)和持续时间(即完成任务所需时间). 当前任务完成后,SJF策略会选择最短持续时间执行任务,若最短持续时间相同,则选择最早请求时间的任务.任务等待时间为请求时间和实际开始时间之差.    "短作业优先"="最短剩余时间优先" 2. 实例: 假设系统一直执行任务,从未空闲.设计程序,输入请求时间表和对应的持续时间表,以及任务数量,计算平均等待时

【ZX笔试】短作业优先算法

时间复杂度为O(n*n),空间复杂度为O(n)的解法 1 // ShortJobFirst.cpp : 定义控制台应用程序的入口点. 2 // 3 4 #include "stdafx.h" 5 #include <iostream> 6 #include <vector> 7 8 using namespace std; 9 10 /* 11 每一步都计算当前时间和总的等待时间,根据当前时间(cpu_time)找到已经就绪的作业下标, 12 保存到vec_re

2017 中心笔试题目 最短作业优先(SJF)

#include <iostream> #include <vector> #include <stdlib.h> #include <algorithm> using namespace std; /********************题目要求*********************************** 最短左右优先,输出总等待时间 测试用例: 任务: A,B,C,D 请求时间:0,2,4,5 持续时间:7,4,1,4 求平均等待时间 ***

短作业调度算法

#include <stdio.h> struct sjf //定义进程的结构体{  char name[10]; //进程名 float arrivetime; //到达时间 float servicetime; //服务时间 float starttime;  //开始时间 float finishtime; //完成时间 float zztime; //周转时间 float dqzztime; //带权周转时间 };  sjf b[100]; //定义短作业优先算法进程的最大数量 voi

短进程优先的调度算法详解

一.SPF算法简介 SJF算法 SJF(shortest job first)是以进程的运行时间长度作为优先级,进程运行时间越短,优先级越高. SJF算法的缺点 必须预知进程的运行时间.即使是程序员也很难准确估计进程运行时间.如果估计过低,系统就可能按估计的时间终止进程的运行,但此时进程并未完成,故一般都会偏长估计 对长进程不利.长进程的周转时间会明显地增长.可怕的是,SJF算法完全忽视进程等待时间,可能使进程等待时间过长,出现饥饿现象. 人机无法实现交互. 完全未考虑进程的紧迫程度.不能保证紧

常见的进程优先调度算法

什么是进程调度以及为什么有进程调度算法 无论是在批处理系统还是分时系统中,用户进程数一般都多于处理机数.这将导致它们互相争夺处理机.另外,系统进程也同样需要使用处理机.这就要求进程调度程序按一定的策略,动态地把处理机分配给处于就绪队列中的某一个进程,以使之执行. 常见的进程调度算法   先进先出算法 算法总是把处理机分配给最先进入就绪队列的进程,一个进程一旦分得处理机,便一直执行下去,直到该进程完成或阻塞时,才释放处理机. 例如,有三个进程P1.P2和P3先后进入就绪队列,它们的执行期分别是21

操作系统——进程调度之短进程优先

 1.什么是进程调度 无论是在批处理系统还是分时系统中,用户进程数一般都多于处理机数.这将导致它们互相争夺处理机.另外,系统进程也同样需要使用处理机.这就要求进程调度程序按一定的策略,动态地把处理机分配给处于就绪队列中的某一个进程,以使之执行. 2.处理机调度分类 高级.中级和低级调度作业从提交开始直到完成,往往要经历下述三级调度: 高级调度:(High-Level Scheduling)又称为作业调度,它决定把后备进程调入内存运行: 低级调度:(Low-Level Scheduling)又称为

最短作业优先调度

#include<stdio.h>#define Time int#define M 100typedef struct process{    char name[M];//进程名    int priority;//优先数    int reachtime;//到达时间    int needtime;//需要时间    int usedtime;//已用时间    int completetime;//完成时间    int time1;//周转时间内    int time2;//带权