时间片轮转调度算法c语言

时间片轮转调度算法是一种常见的进程调度算法，具体实现可以使用C语言。

下面是一个简单的时间片轮转调度算法的C语言实现代码：

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

#define MAX_PROCESS_NUM 100
#define TIME_QUANTUM 2

typedef struct {
    int pid;
    int arrival_time;
    int burst_time;
    int remaining_time;
    int turnaround_time;
    int waiting_time;
    int start_time;
    int finish_time;
} Process;

int main() {
    int n, i, j, time = 0, completed = 0, total_turnaround_time = 0, total_waiting_time = 0;
    float avg_turnaround_time, avg_waiting_time;
    Process processes[MAX_PROCESS_NUM], temp;
    printf("Enter the number of processes: ");
    scanf("%d", &n);
    for(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;
    }
    for(i = 0; i < n; i++) {
        for(j = i + 1; j < n; j++) {
            if(processes[i].arrival_time > processes[j].arrival_time) {
                temp = processes[i];
                processes[i] = processes[j];
                processes[j] = temp;
            }
        }
    }
    printf("\nGantt Chart:\n");
    printf("-----------\n");
    printf("0");
    while(completed < n) {
        for(i = 0; i < n; i++) {
            if(processes[i].arrival_time <= time && processes[i].remaining_time > 0) {
                if(processes[i].remaining_time <= TIME_QUANTUM) {
                    time += processes[i].remaining_time;
                    processes[i].remaining_time = 0;
                    completed++;
                    processes[i].finish_time = time;
                    processes[i].turnaround_time = processes[i].finish_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_waiting_time += processes[i].waiting_time;
                    printf(" -> [P%d] <- %d", processes[i].pid, time);
                } else {
                    time += TIME_QUANTUM;
                    processes[i].remaining_time -= TIME_QUANTUM;
                    printf(" -> [P%d] <- %d", processes[i].pid, time);
                }
            }
        }
        if(completed == n) {
            break;
        }
        printf(" -> idle <- %d", time);
    }
    printf("\n\nProcess\tArrival Time\tBurst Time\tFinish Time\tTurnaround Time\tWaiting Time\n");
    printf("-------\t------------\t----------\t-----------\t---------------\t-------------\n");
    for(i = 0; i < n; i++) {
        printf("P%d\t%d\t\t%d\t\t%d\t\t%d\t\t\t%d\n", processes[i].pid, processes[i].arrival_time, processes[i].burst_time, processes[i].finish_time, processes[i].turnaround_time, processes[i].waiting_time);
    }
    avg_turnaround_time = (float)total_turnaround_time / n;
    avg_waiting_time = (float)total_waiting_time / n;
    printf("\nAverage Turnaround Time: %.2f\n", avg_turnaround_time);
    printf("Average Waiting Time: %.2f\n", avg_waiting_time);
    return 0;
}

代码中定义了一个Process结构体来存储进程的信息，包括进程ID、到达时间、执行时间、剩余执行时间、完成时间、周转时间和等待时间等。在主函数中，首先输入进程的数量和每个进程的到达时间和执行时间，然后按照到达时间对进程进行排序。接着按照时间片轮转的方式执行进程，当进程执行完毕时，计算出进程的完成时间、周转时间和等待时间，并累加到总的周转时间和等待时间中。最后输出每个进程的信息和平均周转时间和等待时间。

注意，这只是一个简单的实现，实际的时间片轮转调度算法还需要考虑很多细节问题，比如进程的优先级、中断处理等。