用c++实现时间片轮转算法的进程调度程序

好的，下面给您提供一个简单的时间片轮转算法的进程调度程序的C++实现，供您参考：

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

// 进程结构体
struct Process {
    int pid;  // 进程ID
    int priority;  // 进程优先级
    int burst_time;  // 进程运行时间
    int remaining_time;  // 进程剩余时间
    int arrival_time;  // 进程到达时间
    int waiting_time;  // 进程等待时间
    int turnaround_time;  // 进程周转时间
    int completion_time;  // 进程完成时间
};

// 比较函数，用于进程优先级排序
bool cmp(Process a, Process b) {
    return a.priority < b.priority;
}

int main() {
    int n; // 进程数
    int quantum; // 时间片长度
    queue<Process> ready_queue; // 就绪队列
    vector<Process> processes; // 进程数组

    // 输入进程数和时间片长度
    cout << "请输入进程数和时间片长度：";
    cin >> n >> quantum;

    // 输入每个进程的信息
    for (int i = 0; i < n; i++) {
        Process p;
        cout << "请输入第" << i + 1 << "个进程的信息：";
        cin >> p.priority >> p.burst_time >> p.arrival_time;
        p.pid = i + 1;
        p.remaining_time = p.burst_time;
        processes.push_back(p);
    }

    // 按照进程到达时间排序
    sort(processes.begin(), processes.end(), [](Process a, Process b) {
        return a.arrival_time < b.arrival_time;
    });

    int current_time = 0; // 当前时间
    int completed_processes = 0; // 完成的进程数

    // 时间片轮转算法
    while (completed_processes < n) {
        // 将到达时间小于等于当前时间的进程加入就绪队列
        while (!processes.empty() && processes[0].arrival_time <= current_time) {
            ready_queue.push(processes[0]);
            processes.erase(processes.begin());
        }

        if (ready_queue.empty()) { // 如果就绪队列为空，直接跳过
            current_time++;
            continue;
        }

        Process p = ready_queue.front(); // 取出队首进程
        ready_queue.pop();

        // 计算等待时间和周转时间
        p.waiting_time += current_time - p.completion_time;
        p.turnaround_time += current_time - p.arrival_time + p.waiting_time;

        // 如果进程剩余时间小于等于时间片长度，直接运行到完成
        if (p.remaining_time <= quantum) {
            current_time += p.remaining_time;
            p.completion_time = current_time;
            p.remaining_time = 0;
            completed_processes++;
        } else { // 否则运行一个时间片长度
            current_time += quantum;
            p.remaining_time -= quantum;
            p.completion_time = current_time;
            ready_queue.push(p); // 放回就绪队列
        }
    }

    // 输出结果
    double total_waiting_time = 0, total_turnaround_time = 0;
    for (auto p : processes) {
        total_waiting_time += p.waiting_time;
        total_turnaround_time += p.turnaround_time;
        cout << "进程" << p.pid << "：等待时间=" << p.waiting_time << " 周转时间=" << p.turnaround_time << endl;
    }
    cout << "平均等待时间：" << total_waiting_time / n << endl;
    cout << "平均周转时间：" << total_turnaround_time / n << endl;

    return 0;
}

以上就是一个简单的时间片轮转算法的进程调度程序的C++实现，希望能对您有所帮助。