基于c++ 的时间片轮转调度算法的代码
时间: 2024-05-14 14:16:26 浏览: 11
下面是一个基于 C 语言的时间片轮转调度算法的代码示例:
```c
#include <stdio.h>
//定义进程结构体
typedef struct process {
int pid; //进程ID
int burst_time; //进程执行时间
int waiting_time; //等待时间
int turnaround_time; //周转时间
int remaining_time; //剩余执行时间
} Process;
//时间片轮转调度
void round_robin_scheduling(Process processes[], int n, int time_quantum) {
int i, j, t, remaining_processes = n;
int current_time = 0, current_process = 0;
int completed_processes[n];
int total_waiting_time = 0, total_turnaround_time = 0;
//初始化剩余执行时间和等待时间
for (i = 0; i < n; i++) {
processes[i].remaining_time = processes[i].burst_time;
processes[i].waiting_time = 0;
}
//开始调度进程
while (remaining_processes > 0) {
//执行当前进程
if (processes[current_process].remaining_time <= time_quantum && processes[current_process].remaining_time > 0) {
//当前进程可以在时间片内完成
current_time += processes[current_process].remaining_time;
processes[current_process].remaining_time = 0;
t = 1;
} else {
//当前进程需要多个时间片
current_time += time_quantum;
processes[current_process].remaining_time -= time_quantum;
t = 0;
}
//更新等待时间和周转时间
for (j = 0; j < n; j++) {
if (processes[j].burst_time > 0 && processes[j].pid != processes[current_process].pid) {
processes[j].waiting_time += t;
}
if (processes[j].burst_time == 0 && processes[j].pid == processes[current_process].pid) {
processes[j].turnaround_time = current_time;
completed_processes[remaining_processes - 1] = processes[j].pid;
remaining_processes--;
}
}
//选择下一个要执行的进程
if (current_process == n - 1) {
current_process = 0;
} else if (processes[current_process + 1].burst_time == 0) {
current_process++;
} else {
for (i = current_process + 1; i < n; i++) {
if (processes[i].burst_time > 0) {
current_process = i;
break;
}
if (i == n - 1) {
i = -1;
}
}
}
}
//计算平均等待时间和平均周转时间
for (i = 0; i < n; i++) {
processes[i].turnaround_time = processes[i].turnaround_time - processes[i].waiting_time;
total_waiting_time += processes[i].waiting_time;
total_turnaround_time += processes[i].turnaround_time;
}
printf("进程ID\t执行时间\t等待时间\t周转时间\n");
for (i = 0; i < n; i++) {
printf("%d\t%d\t\t%d\t\t%d\n", processes[i].pid, processes[i].burst_time, processes[i].waiting_time, processes[i].turnaround_time);
}
printf("平均等待时间:%f\n", (float)total_waiting_time / n);
printf("平均周转时间:%f\n", (float)total_turnaround_time / n);
}
int main() {
int n, i, time_quantum;
printf("输入进程数:");
scanf("%d", &n);
printf("输入时间片:");
scanf("%d", &time_quantum);
Process processes[n];
printf("输入进程执行时间:");
for (i = 0; i < n; i++) {
processes[i].pid = i + 1;
scanf("%d", &processes[i].burst_time);
}
round_robin_scheduling(processes, n, time_quantum);
return 0;
}
```
该代码中定义了一个 `Process` 结构体,用于存储进程的相关信息。`round_robin_scheduling` 函数实现了时间片轮转调度算法,其中参数 `processes` 是一个进程数组,`n` 是进程数,`time_quantum` 是时间片。
主函数中首先输入进程数和时间片,然后输入每个进程的执行时间,并调用 `round_robin_scheduling` 函数对进程进行调度。最后输出每个进程的执行时间、等待时间和周转时间,以及平均等待时间和平均周转时间。