用C语言编写“最短作业优先(SJF)” 调度算法,编写以 下函数,计算平均带权周转时间并返回。 注意: 1)不要修改函数名、函数返回类型、参数个数、参数名和参数类型。 2)函数输入参数说明: arrival_time:作业达到时间数组 run_time: 作业运行时间数组 num:作业数 3)函数返回值:作业平均带权周转时间
时间: 2024-02-23 22:02:12 浏览: 24
以下是用 C 语言编写的计算 SJF 调度算法平均带权周转时间的函数:
```c
float sjf(float arrival_time[], float run_time[], int num) {
float wait_time[num]; // 等待时间数组
float tat[num]; // 周转时间数组
float total_wt = 0, total_tat = 0; // 总等待时间和总周转时间
int i, j;
// 计算等待时间和周转时间
for (i = 0; i < num; i++) {
wait_time[i] = 0;
tat[i] = 0;
for (j = 0; j < i; j++) {
wait_time[i] += run_time[j];
}
tat[i] = wait_time[i] + run_time[i];
total_wt += wait_time[i];
total_tat += tat[i];
}
// 计算平均带权周转时间并返回
return total_tat / total_wt;
}
```
此函数实现了 SJF 调度算法,并计算了平均带权周转时间,输入参数为作业达到时间数组、作业运行时间数组和作业数,返回值为作业平均带权周转时间。
相关问题
编写C语言程序,模拟“最短作业优先(SJF)” 调度算法,编写以下函数,计算平均带权周转时间并返回。 注意:1)不要修改函数名、函数返回类型、参数个数、参数名和参数类型。2)函数输入参数说明:arrival_time:作业达到时间数组run_time: 作业运行时间数组num:作业数3)函数返回值:作业平均带权周转时间
以下是实现最短作业优先(SJF)算法计算平均带权周转时间的 C 语言代码:
```c
float sjf(float arrival_time[], float run_time[], int num) {
float completion_time[num], turn_around_time[num], waiting_time[num], total_waiting_time = 0, total_turn_around_time = 0;
// 完成时间初始化为0
for (int i = 0; i < num; i++) {
completion_time[i] = 0;
}
// 按到达时间排序作业
for (int i = 0; i < num; i++) {
for (int j = i + 1; j < num; j++) {
if (arrival_time[i] > arrival_time[j]) {
float temp = arrival_time[i];
arrival_time[i] = arrival_time[j];
arrival_time[j] = temp;
temp = run_time[i];
run_time[i] = run_time[j];
run_time[j] = temp;
}
}
}
// 计算完成时间和周转时间
for (int i = 0; i < num; i++) {
if (i == 0) {
completion_time[i] = arrival_time[i] + run_time[i];
} else {
if (arrival_time[i] > completion_time[i - 1]) {
completion_time[i] = arrival_time[i] + run_time[i];
} else {
completion_time[i] = completion_time[i - 1] + run_time[i];
}
}
turn_around_time[i] = completion_time[i] - arrival_time[i];
}
// 计算带权周转时间和平均带权周转时间
for (int i = 0; i < num; i++) {
waiting_time[i] = turn_around_time[i] - run_time[i];
total_waiting_time += waiting_time[i];
total_turn_around_time += turn_around_time[i];
}
return total_turn_around_time / num / run_time[0];
}
```
该函数的参数为到达时间数组 `arrival_time`、运行时间数组 `run_time` 和作业数 `num`。函数返回值为计算得到的平均带权周转时间。
函数首先初始化完成时间数组为0,然后按到达时间对作业进行排序。接着,计算完成时间和周转时间,并计算带权周转时间和平均带权周转时间,最后返回平均带权周转时间。
用c语言编写程序,编写并调试一个模拟的进程调度程序,采用 “短进程优先”调度算法对多个进程进行调度。计算平均周转时间和平均带权周转时间。
以下是一个简单的 C 语言程序,使用短进程优先调度算法对多个进程进行调度,并计算平均周转时间和平均带权周转时间。程序中包含了一些随机生成的进程,你也可以根据自己的需要修改它。
```
#include <stdio.h>
#include <stdlib.h>
// 进程结构体
typedef struct {
int pid; // 进程 ID
int arrival_time; // 到达时间
int burst_time; // 运行时间
int waiting_time; // 等待时间
int turnaround_time; // 周转时间
} Process;
// 生成随机进程
void generate_processes(Process *processes, int n) {
int i;
for (i = 0; i < n; i++) {
processes[i].pid = i;
processes[i].arrival_time = rand() % 10;
processes[i].burst_time = rand() % 10 + 1;
processes[i].waiting_time = 0;
processes[i].turnaround_time = 0;
}
}
// 短进程优先调度算法
void sjf(Process *processes, int n) {
int i, j;
Process temp;
for (i = 0; i < n - 1; i++) {
for (j = i + 1; j < n; j++) {
if (processes[i].burst_time > processes[j].burst_time) {
temp = processes[i];
processes[i] = processes[j];
processes[j] = temp;
}
}
}
int current_time = 0;
float total_turnaround_time = 0, total_weighted_turnaround_time = 0;
for (i = 0; i < n; i++) {
current_time += processes[i].burst_time;
processes[i].turnaround_time = current_time - processes[i].arrival_time;
processes[i].waiting_time = processes[i].turnaround_time - processes[i].burst_time;
total_turnaround_time += processes[i].turnaround_time;
total_weighted_turnaround_time += (float) processes[i].turnaround_time / processes[i].burst_time;
}
printf("PID\tArrival Time\tBurst Time\tWaiting Time\tTurnaround Time\n");
for (i = 0; i < n; i++) {
printf("%d\t%d\t\t%d\t\t%d\t\t%d\n", processes[i].pid, processes[i].arrival_time, processes[i].burst_time, processes[i].waiting_time, processes[i].turnaround_time);
}
printf("Average turnaround time: %.2f\n", total_turnaround_time / n);
printf("Average weighted turnaround time: %.2f\n", total_weighted_turnaround_time / n);
}
int main() {
int n = 5;
Process processes[n];
generate_processes(processes, n);
sjf(processes, n);
return 0;
}
```
程序中,我们使用 `generate_processes` 函数生成了 5 个随机进程,每个进程的到达时间和运行时间都是随机的。然后,我们使用 `sjf` 函数对进程进行调度,并计算平均周转时间和平均带权周转时间。
在 `sjf` 函数中,我们使用了冒泡排序算法来按照运行时间对进程进行排序。然后,我们按照排序后的顺序依次计算每个进程的等待时间和周转时间,并计算总的平均周转时间和平均带权周转时间。
最后,程序输出了每个进程的详细信息、平均周转时间和平均带权周转时间。