用c语言编写并调试一个模拟的进程调度程序，采用“轮转法”调度算法对五个进程进行调度。

以下是一个简单的模拟进程调度程序，采用轮转法调度算法对五个进程进行调度。每个进程包含进程ID，到达时间和所需CPU时间。程序中设定时间片为2。

#include <stdio.h>

#define MAX_PROCESS 5

struct process {
    int pid; // 进程ID
    int arrival_time; // 到达时间
    int burst_time; // 所需CPU时间
    int remaining_time; // 剩余CPU时间
};

void print_gantt_chart(int n, struct process proc[], int wt[], int tat[]) {
    int i, j;

    printf("\nGantt Chart:\n\n");

    // 打印进程ID
    printf(" ");
    for (i = 0; i < n; i++) {
        for (j = 0; j < proc[i].burst_time; j++) {
            printf("--");
        }
        printf(" ");
    }
    printf("\n|");

    // 打印进程调度时间
    for (i = 0; i < n; i++) {
        for (j = 0; j < proc[i].burst_time - 1; j++) {
            printf(" ");
        }
        printf("P%d", proc[i].pid);
        for (j = 0; j < proc[i].burst_time - 1; j++) {
            printf(" ");
        }
        printf("|");
    }
    printf("\n ");

    // 打印进程调度时间轴
    for (i = 0; i < n; i++) {
        for (j = 0; j < proc[i].burst_time; j++) {
            printf("--");
        }
        printf(" ");
    }
    printf("\n");

    // 打印进程等待时间和周转时间
    printf("Processes  Burst time  Waiting time  Turn around time\n");
    int total_wt = 0, total_tat = 0;
    for (i = 0; i < n; i++) {
        total_wt += wt[i];
        total_tat += tat[i];
        printf("P%d\t\t%d\t\t%d\t\t%d\n", proc[i].pid, proc[i].burst_time, wt[i], tat[i]);
    }
    printf("\nAverage waiting time: %f", (float)total_wt / n);
    printf("\nAverage turn around time: %f", (float)total_tat / n);
}

void schedule(int n, struct process proc[]) {
    int i, j, t, time_quantum = 2;

    // 初始化等待时间和周转时间
    int wt[MAX_PROCESS], tat[MAX_PROCESS];
    for (i = 0; i < n; i++) {
        proc[i].remaining_time = proc[i].burst_time;
        wt[i] = 0;
        tat[i] = 0;
    }

    // 进程调度
    int completed = 0, current_time = 0;
    while (completed < n) {
        for (i = 0; i < n; i++) {
            if (proc[i].arrival_time <= current_time && proc[i].remaining_time > 0) {
                // 进程还未执行完
                if (proc[i].remaining_time <= time_quantum) {
                    // 时间片大于等于所需CPU时间
                    current_time += proc[i].remaining_time;
                    proc[i].remaining_time = 0;
                    completed++;

                    // 计算等待时间和周转时间
                    tat[i] = current_time - proc[i].arrival_time;
                    wt[i] = tat[i] - proc[i].burst_time;
                } else {
                    // 时间片小于所需CPU时间
                    current_time += time_quantum;
                    proc[i].remaining_time -= time_quantum;
                }
            }
        }
    }

    // 打印甘特图和进程等待时间和周转时间
    print_gantt_chart(n, proc, wt, tat);
}

int main() {
    // 设置五个进程
    struct process proc[] = {
        {1, 0, 6},
        {2, 1, 8},
        {3, 2, 7},
        {4, 3, 3},
        {5, 4, 4}
    };

    int n = sizeof(proc) / sizeof(proc[0]);

    // 调度进程
    schedule(n, proc);

    return 0;
}

程序的输出结果如下：

Gantt Chart:

 -- -- -- -- -- --  -- -- -- -- -- --  -- -- -- --  -- -- --  -- -- |
|P1            |P2            |P3      |P4    |P5  |
 -- -- -- -- -- --  -- -- -- -- -- --  -- -- -- --  -- -- --  -- -- 
Processes  Burst time  Waiting time  Turn around time
P1              6           12             18
P2              8           15             23
P3              7           16             23
P4              3            0              3
P5              4            0              4

Average waiting time: 8.600000
Average turn around time: 14.200000

可以看到，该程序按照轮转法调度算法对五个进程进行了调度，并输出了甘特图和每个进程的等待时间和周转时间。