最高优先数优先算法C++

最高优先数优先算法是一种进程调度算法，它的思想是将进程按照优先数的大小进行排序，优先数越大的进程越先被调度执行。下面是一个简单的最高优先数优先算法的C++实现：

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

struct Process {
    int pid; // 进程ID
    int priority; // 优先数
    int burst_time; // 执行时间
    int arrival_time; // 到达时间
};

bool operator<(const Process &p1, const Process &p2) {
    return p1.priority < p2.priority;
}

int main() {
    int n; // 进程数
    cin >> n;
    vector<Process> processes(n);
    for (int i = 0; i < n; i++) {
        processes[i].pid = i + 1;
        cin >> processes[i].priority >> processes[i].burst_time >> processes[i].arrival_time;
    }
    sort(processes.begin(), processes.end()); // 按照优先数进行排序
    int time = 0; // 当前时间
    priority_queue<Process> q; // 优先队列
    int wait_time = 0; // 等待时间
    int turnaround_time = 0; // 周转时间
    for (int i = 0; i < n; i++) {
        while (!q.empty() && q.top().burst_time <= 0) {
            // 当前进程执行完毕，弹出队列
            turnaround_time += time - q.top().arrival_time;
            q.pop();
        }
        if (q.empty() && time < processes[i].arrival_time) {
            time = processes[i].arrival_time; // 等待进程到达
        }
        q.push(processes[i]); // 将进程加入队列
        wait_time += time - processes[i].arrival_time;
        time += processes[i].burst_time; // 执行进程
    }
    while (!q.empty()) {
        // 处理队列中剩余的进程
        while (!q.empty() && q.top().burst_time <= 0) {
            turnaround_time += time - q.top().arrival_time;
            q.pop();
        }
        if (!q.empty()) {
            wait_time += time - q.top().arrival_time;
            time += q.top().burst_time;
            turnaround_time += time - q.top().arrival_time;
            q.pop();
        }
    }
    cout << "平均等待时间：" << (double)wait_time / n << endl;
    cout << "平均周转时间：" << (double)turnaround_time / n << endl;
    return 0;
}

上述实现中，我们使用了一个优先队列来存储进程，每次从队列中取出优先数最高的进程进行执行。在处理队列中剩余的进程时，需要注意判断当前进程是否已经执行完毕，如果已经执行完毕，则需要将其从队列中弹出。最后，根据等待时间和周转时间的定义计算出它们的平均值并输出即可。