c语言实现SRT调度算法

SRT（Shortest Remaining Time）调度算法是一种短作业优先调度算法的变种，其目的是使等待时间最短的进程先执行。在SRT算法中，每当一个新的进程到达，就会比较其剩余运行时间与当前正在运行的进程剩余运行时间的大小，并根据结果进行调度。

下面是一个使用C语言实现SRT调度算法的示例代码：

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

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

int main() {
    int n;  // 进程数
    printf("Enter the number of processes: ");
    scanf("%d", &n);

    struct Process *processes = (struct Process*) malloc(n * sizeof(struct Process));
    for (int i = 0; i < n; i++) {
        printf("Enter the arrival time and burst time of process %d: ", i + 1);
        scanf("%d%d", &processes[i].arrival_time, &processes[i].burst_time);
        processes[i].pid = i + 1;
        processes[i].remaining_time = processes[i].burst_time;
    }

    int current_time = 0;  // 当前时间
    int completed = 0;  // 完成的进程数
    int total_waiting_time = 0;  // 总等待时间
    int total_turnaround_time = 0;  // 总周转时间

    while (completed < n) {
        int index = -1;
        int min_remaining_time = 1000000;
        // 找到剩余时间最短的进程
        for (int i = 0; i < n; i++) {
            if (processes[i].arrival_time <= current_time && processes[i].remaining_time < min_remaining_time && processes[i].remaining_time > 0) {
                index = i;
                min_remaining_time = processes[i].remaining_time;
            }
        }
        if (index == -1) {
            current_time++;
            continue;
        }
        // 执行进程
        processes[index].remaining_time--;
        current_time++;
        if (processes[index].remaining_time == 0) {
            // 计算等待时间和周转时间
            processes[index].waiting_time = current_time - processes[index].arrival_time - processes[index].burst_time;
            processes[index].turnaround_time = current_time - processes[index].arrival_time;
            // 统计总等待时间和总周转时间
            total_waiting_time += processes[index].waiting_time;
            total_turnaround_time += processes[index].turnaround_time;
            completed++;
        }
    }

    // 计算平均等待时间和平均周转时间
    float average_waiting_time = (float) total_waiting_time / n;
    float average_turnaround_time = (float) total_turnaround_time / n;
    printf("Average waiting time: %.2f\n", average_waiting_time);
    printf("Average turnaround time: %.2f\n", average_turnaround_time);

    // 打印结果
    printf("Process\tArrival time\tBurst time\tWaiting time\tTurnaround time\n");
    for (int i = 0; i < n; i++) {
        printf("%d\t\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);
    }

    free(processes);
    return 0;
}

在上面的代码中，我们首先输入进程数和每个进程的到达时间和执行时间，然后使用结构体存储每个进程的相关信息。接下来，我们使用while循环执行SRT算法，直到所有进程都完成。在每次循环中，我们找到剩余时间最短的进程并执行它，然后更新当前时间。如果一个进程执行完毕，我们就计算它的等待时间和周转时间，并统计总等待时间和总周转时间。最后，我们计算平均等待时间和平均周转时间，并打印出每个进程的详细信息。

需要注意的是，上面的代码只是一个简单的示例，实际应用中需要考虑更多的情况，比如进程的优先级、时间片大小等等。