C语言设计时间轮转算法

时间片轮转算法是一种常见的进程调度算法，它的基本思想是将所有处于就绪状态的进程按照先后顺序排成一个队列，然后每个进程按照一定的时间轮流占用CPU。当一个进程用完它分配的时间片后，它就会被移到队列的末尾，等待下一次调度。

下面是一个简单的C语言实现时间片轮转算法的例子：

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

struct process {
    int pid;  // 进程ID
    int burst_time;  // 进程执行时间
    int remaining_time;  // 进程剩余执行时间
    int arrival_time;  // 进程到达时间
    int waiting_time;  // 进程等待时间
    int turnaround_time;  // 进程周转时间
};

void calculate_waiting_time(struct process *procs, int n, int quantum) {
    int total_time = 0;  // 总执行时间
    int remaining_procs = n;  // 剩余未执行进程数
    int current_time = 0;  // 当前时间
    int i, j;

    // 计算剩余执行时间
    for (i = 0; i < n; i++) {
        procs[i].remaining_time = procs[i].burst_time;
    }

    // 时间片轮转
    while (remaining_procs > 0) {
        for (i = 0; i < n; i++) {
            if (procs[i].remaining_time <= 0) {
                continue;
            }

            if (procs[i].remaining_time > quantum) {
                // 执行一个时间片
                current_time += quantum;
                procs[i].remaining_time -= quantum;
            } else {
                // 执行完整个进程
                current_time += procs[i].remaining_time;
                procs[i].remaining_time = 0;
                remaining_procs--;

                // 计算等待时间和周转时间
                procs[i].turnaround_time = current_time - procs[i].arrival_time;
                procs[i].waiting_time = procs[i].turnaround_time - procs[i].burst_time;
                if (procs[i].waiting_time < 0) {
                    procs[i].waiting_time = 0;
                }
                total_time += procs[i].waiting_time;
            }
        }
    }

    // 计算平均等待时间
    double avg_waiting_time = (double) total_time / n;
    printf("Average waiting time: %.2f\n", avg_waiting_time);
}

int main() {
    // 创建进程数组
    int n = 5;
    struct process procs[] = {
        {1, 6, 0, 0, 0, 0},
        {2, 8, 0, 1, 0, 0},
        {3, 7, 0, 2, 0, 0},
        {4, 3, 0, 3, 0, 0},
        {5, 4, 0, 4, 0, 0}
    };

    // 计算等待时间
    int quantum = 3;
    calculate_waiting_time(procs, n, quantum);

    return 0;
}

这个例子中，我们定义了一个进程结构体，它包含进程的ID、执行时间、剩余执行时间、到达时间、等待时间和周转时间。然后，我们实现了一个`calculate_waiting_time`函数，它采用时间片轮转算法计算每个进程的等待时间和周转时间，并最终计算出平均等待时间。在`main`函数中，我们创建了一个包含5个进程的进程数组，并调用`calculate_waiting_time`函数计算等待时间，时间片长度为3个时间单位。