用c++编写程序，实现FPF算法，模拟进程调度过程

FPF算法全称为“最短作业优先算法”，是一种非抢占式的调度算法，它根据每个进程的运行时间来确定优先级，运行时间越短的进程优先级越高。下面是用C++实现FPF算法的代码：

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

// 进程结构体
struct Process {
    int id; // 进程ID
    int arrival_time; // 到达时间
    int burst_time; // 运行时间
    int priority; // 优先级
};

// 比较函数，用于优先队列的排序
struct CompareProcess {
    bool operator()(Process const& p1, Process const& p2) {
        // 运行时间越短的进程优先级越高
        return p1.burst_time > p2.burst_time;
    }
};

// FPF算法，输入进程列表和进程数目，返回平均等待时间
float fpf(Process processes[], int n) {
    priority_queue<Process, vector<Process>, CompareProcess> ready_queue; // 就绪队列
    int current_time = 0; // 当前时间
    int total_wait_time = 0; // 总等待时间

    int i = 0;
    while (!ready_queue.empty() || i < n) {
        // 将到达时间小于等于当前时间的进程加入就绪队列
        while (i < n && processes[i].arrival_time <= current_time) {
            ready_queue.push(processes[i]);
            i++;
        }

        // 从就绪队列中取出运行时间最短的进程
        if (!ready_queue.empty()) {
            Process p = ready_queue.top();
            ready_queue.pop();

            // 更新当前时间和总等待时间
            current_time += p.burst_time;
            total_wait_time += current_time - p.arrival_time - p.burst_time;
        }
        else {
            // 如果就绪队列为空，则将当前时间更新为下一个进程的到达时间
            current_time = processes[i].arrival_time;
        }
    }

    // 返回平均等待时间
    return (float)total_wait_time / n;
}

int main() {
    // 输入进程数目和每个进程的到达时间和运行时间
    int n;
    cout << "Enter the number of processes: ";
    cin >> n;

    Process processes[n];
    for (int i = 0; i < n; i++) {
        processes[i].id = i + 1;
        cout << "Enter arrival time and burst time for process " << i + 1 << ": ";
        cin >> processes[i].arrival_time >> processes[i].burst_time;
    }

    // 计算平均等待时间并输出结果
    float avg_wait_time = fpf(processes, n);
    cout << "Average waiting time: " << avg_wait_time << endl;

    return 0;
}

在这个程序中，我们使用了一个结构体来表示进程，包括进程ID、到达时间、运行时间和优先级。我们还定义了一个比较函数来实现优先队列的排序。在`fpf`函数中，我们使用一个优先队列来维护就绪队列，每次取出运行时间最短的进程进行运行，并更新当前时间和总等待时间。最后，我们返回平均等待时间作为程序的输出结果。