含有5个进程的简单轮转法调度算法代码

以下是一个使用C++实现的简单轮转法调度算法的代码示例，针对上述5个进程进行调度：

#include <iostream>
#include <queue>
using namespace std;

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

void round_robin(process p[], int n, int quantum)
{
    queue<process> q;
    int t = 0; // 当前时间
    int completed = 0; // 已完成的进程数
    int total_waiting_time = 0; // 总等待时间
    int total_turnaround_time = 0; // 总周转时间
    
    // 将所有进程按到达时间入队
    for (int i = 0; i < n; i++)
        q.push(p[i]);
    
    // 循环调度所有进程，直到所有进程都完成
    while (completed < n)
    {
        process curr = q.front();
        q.pop();
        
        // 计算该进程的等待时间
        curr.waiting_time += t - curr.completion_time;
        
        // 如果该进程的剩余执行时间小于时间片，则执行完毕
        if (curr.remaining_time <= quantum)
        {
            t += curr.remaining_time;
            curr.completion_time = t;
            curr.turnaround_time = t - curr.arrival_time;
            curr.remaining_time = 0;
            completed++;
        }
        // 否则，该进程暂时退出CPU，剩余执行时间减去时间片，并重新入队
        else
        {
            t += quantum;
            curr.remaining_time -= quantum;
            q.push(curr);
        }
        
        // 统计总等待时间和总周转时间
        total_waiting_time += curr.waiting_time;
        total_turnaround_time += curr.turnaround_time;
    }
    
    // 输出每个进程的相关信息
    cout << "Process\tArrival Time\tBurst Time\tCompletion Time\tTurnaround Time\tWaiting Time\n";
    for (int i = 0; i < n; i++)
        cout << "P" << p[i].pid << "\t" << p[i].arrival_time << "\t\t" << p[i].burst_time << "\t\t" << p[i].completion_time << "\t\t" << p[i].turnaround_time << "\t\t" << p[i].waiting_time << endl;
    
    // 输出平均等待时间和平均周转时间
    double avg_waiting_time = (double)total_waiting_time / n;
    double avg_turnaround_time = (double)total_turnaround_time / n;
    cout << "Average Waiting Time: " << avg_waiting_time << endl;
    cout << "Average Turnaround Time: " << avg_turnaround_time << endl;
}

int main()
{
    // 创建进程数组
    process p[] = {
        {1, 0, 10, 10, 0, 0, 0},
        {2, 1, 5, 5, 0, 0, 0},
        {3, 2, 8, 8, 0, 0, 0},
        {4, 3, 3, 3, 0, 0, 0},
        {5, 4, 4, 4, 0, 0, 0}
    };
    int n = sizeof(p) / sizeof(p[0]);
    
    // 调用简单轮转法调度算法，时间片为2
    round_robin(p, n, 2);
    
    return 0;
}

上述代码中的`process`结构体记录了每个进程的相关信息，`round_robin`函数实现了简单轮转法调度算法，其中`quantum`表示时间片大小。该算法先将所有进程按到达时间入队，然后循环调度所有进程，直到所有进程都完成。在每次调度过程中，算法先从队列中取出一个进程，计算该进程的等待时间，并根据其剩余执行时间判断其是否能在该时间片内完成。如果该进程能够完成，则计算其完成时间和周转时间，并将已完成的进程数加一；否则，该进程暂时退出CPU，剩余执行时间减去时间片，并重新入队。最后，算法统计所有进程的总等待时间和总周转时间，并输出每个进程的相关信息和平均等待时间、平均周转时间。

以上是一个简单的轮转法调度算法的实现，仅供参考。实际应用中，需要根据具体情况进行调整和优化。