编写C程序模拟实现单处理机系统中进程调度，实现对多个进程的调度模拟，要求采用多级反馈队列调度算法进行模拟调度。（江西师范大学）

编写C程序模拟实现单处理机系统中进程调度，实现对多个进程的调度模拟，要求采用多级反馈队列调度算法进行模拟调度。

数据结构设计：PCB：结构体；就绪队列：每个节点为进程PCB；进程状态

具体调度算法：FCFS、SJF、PR；涉及多种操作：排序、链表操作

程序输出设计：调度进程的顺序、每个进程的起始时间、终止时间等CPU每次调度的过程

分析：关于链表的一些功能，如果说能够使用STL的话，能省去手写链表的时间，且更加安全。

然后是对多个进程之间的模拟调度，可以用STL的queue来模拟队列，然后用vector来代替链表。

记住，在c++里面，用了对应的一些功能的函数，可能是要加上一些头文件的。

这里因为是用了vector，所以加了头文件#include<vector>

同时也用了queue，所以加上了#include<queue>

下面是运行结果：

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

// 进程结构体，包含进程ID、需要运行的时间、剩余运行时间和所在的队列
struct Process {
    int pid;
    int time_needed;
    int remaining_time;
    int queue_level;
};

int main() {
    int n, m, quantum;
    cout << "Enter the number of queues: ";
    cin >> n;
    cout << "Enter the number of processes: ";
    int num_processes;
    cin >> num_processes;
    cout << "Enter the number of time slices for each queue: ";
    cin >> quantum;

    // 创建 n 个队列
    vector<queue<Process>> queues(n);

    // 输入进程信息
    for (int i = 0; i < num_processes; i++) {
        Process p;
        cout << "Enter the process ID: ";
        cin >> p.pid;
        cout << "Enter the time needed for the process: ";
        cin >> p.time_needed;
        p.remaining_time = p.time_needed;
        p.queue_level = 0; // 初始时所有进程都在最高优先级队列
        queues[0].push(p);
    }

    // 模拟调度过程，每次处理一个时间片
    int current_time = 0;
    while (true) {
        bool all_queues_empty = true;
        for (int current_level = 0; current_level < n; current_level++) {
            if (queues[current_level].empty()) continue;
            all_queues_empty = false;
            Process p = queues[current_level].front();
            queues[current_level].pop();

            // 输出当前时间片运行的进程
            cout << "Time " << current_time << " - Running process " << p.pid << " in queue " << current_level << endl;

            // 运行当前时间片
            p.remaining_time -= quantum;

            // 如果进程还未执行完，则将其加入下一级队列中
            if (p.remaining_time > 0) {
                p.queue_level = min(current_level + 1, n - 1);
                queues[p.queue_level].push(p);
            }
        }
        if (all_queues_empty) break;
        current_time += quantum;
    }

    return 0;
}