b编写c或c++程序实现最短剩余时间优先算法

以下是一个使用 C++ 实现最短剩余时间优先算法的示例程序：

#include <iostream>
#include <queue>
#include <vector>

using namespace std;

struct Process {
    int pid; // 进程 ID
    int arrival_time; // 到达时间
    int burst_time; // 运行时间
    int remaining_time; // 剩余时间

    Process(int pid, int arrival_time, int burst_time) {
        this->pid = pid;
        this->arrival_time = arrival_time;
        this->burst_time = burst_time;
        this->remaining_time = burst_time;
    }
};

bool operator<(const Process &a, const Process &b) {
    return a.remaining_time > b.remaining_time;
}

void shortestRemainingTimeFirst(vector<Process> &process_list) {
    int n = process_list.size();
    priority_queue<Process> pq;
    int current_time = 0;
    int total_waiting_time = 0;
    int total_turnaround_time = 0;

    // 按到达时间排序
    sort(process_list.begin(), process_list.end(), [](const Process &a, const Process &b) {
        return a.arrival_time < b.arrival_time;
    });

    // 开始调度
    int i = 0;
    while (i < n || !pq.empty()) {
        // 将到达时间小于等于当前时间的进程加入队列
        while (i < n && process_list[i].arrival_time <= current_time) {
            pq.push(process_list[i]);
            i++;
        }
        if (pq.empty()) {
            // 队列为空，当前时间跳到下一个进程到达时间
            current_time = process_list[i].arrival_time;
        } else {
            // 执行队首进程
            Process p = pq.top();
            pq.pop();
            total_waiting_time += current_time - p.arrival_time;
            current_time += p.remaining_time;
            total_turnaround_time += current_time - p.arrival_time - p.burst_time;
            // 更新剩余时间
            p.remaining_time = 0;
            // 处理后续到达的进程
            while (i < n && process_list[i].arrival_time <= current_time) {
                if (process_list[i].remaining_time < p.remaining_time) {
                    // 抢占当前进程
                    p.remaining_time -= current_time - process_list[i].arrival_time;
                    pq.push(p);
                    p = process_list[i];
                } else {
                    // 加入队列
                    pq.push(process_list[i]);
                }
                i++;
            }
            if (p.remaining_time > 0) {
                // 将剩余时间不为 0 的进程加入队列
                pq.push(p);
            }
        }
    }

    // 输出结果
    int total_time = current_time - process_list[0].arrival_time;
    int num_processes = process_list.size();
    double avg_waiting_time = (double) total_waiting_time / num_processes;
    double avg_turnaround_time = (double) total_turnaround_time / num_processes;
    printf("Total time: %d\n", total_time);
    printf("Average waiting time: %.2f\n", avg_waiting_time);
    printf("Average turnaround time: %.2f\n", avg_turnaround_time);
}

int main() {
    vector<Process> process_list = {
        Process(1, 0, 5),
        Process(2, 2, 3),
        Process(3, 3, 2),
        Process(4, 5, 4),
        Process(5, 6, 2)
    };
    shortestRemainingTimeFirst(process_list);
    return 0;
}

该程序实现了 SRTF 算法，并对一个进程列表进行调度，输出了总时间、平均等待时间和平均周转时间。需要注意的是，在实际使用中，进程到达时间和运行时间需要从外部读入，而不是在程序中硬编码。