C++最高优先数优先算法算周转时间和带权周转时间

C++最高优先数优先算法是一种非抢占式的调度算法，即当一个进程被调度后，它将一直运行直到完成或者被一个更高优先级的进程抢占。该算法可计算出每个进程的周转时间和带权周转时间。

周转时间：指从进程进入系统开始到进程结束所经历的时间。计算公式为：Turnaround time = Completion time - Arrival time

带权周转时间：指进程等待时间和运行时间的比例。计算公式为：Weighted turnaround time = Turnaround time / Burst time

其中，Arrival time表示进程到达时间，Completion time表示进程完成时间，Burst time表示进程运行时间。

在C++最高优先数优先算法中，每个进程都有一个优先级，当一个进程到达时，系统会比较该进程的优先级和当前正在运行的进程的优先级，如果该进程的优先级高于当前正在运行的进程的优先级，则该进程将被调度运行，否则等待直到当前进程运行结束。当一个进程完成后，系统会比较所有等待中进程的优先级，选择优先级最高的进程运行。

通过对每个进程的完成时间和运行时间进行计算，可以得到每个进程的周转时间和带权周转时间。

相关问题

C++计算周转时间和带权周转时间的最高优先数优先算法

以下是使用C++实现计算周转时间和带权周转时间的最高优先数优先算法的示例代码：

#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

struct Process {
    int pid; // 进程ID
    int arrival_time; // 到达时间
    int burst_time; // 运行时间
    int priority; // 优先级
    int completion_time; // 完成时间
    int turnaround_time; // 周转时间
    double weighted_turnaround_time; // 带权周转时间
};

bool compare(Process a, Process b) {
    return a.priority > b.priority;
}

int main() {
    int n; // 进程数量
    cout << "请输入进程数量：";
    cin >> n;

    vector<Process> processes(n);

    // 输入进程信息
    for(int i = 0; i < n; i++) {
        processes[i].pid = i + 1;
        cout << "请输入进程" << i + 1 << "的到达时间、运行时间和优先级：";
        cin >> processes[i].arrival_time >> processes[i].burst_time >> processes[i].priority;
    }

    // 按照优先级排序
    sort(processes.begin(), processes.end(), compare);

    // 计算完成时间、周转时间和带权周转时间
    int current_time = 0;
    for(int i = 0; i < n; i++) {
        current_time += processes[i].burst_time;
        processes[i].completion_time = current_time;
        processes[i].turnaround_time = processes[i].completion_time - processes[i].arrival_time;
        processes[i].weighted_turnaround_time = (double)processes[i].turnaround_time / processes[i].burst_time;
    }

    // 输出结果
    cout << "进程ID\t到达时间\t运行时间\t优先级\t完成时间\t周转时间\t带权周转时间" << endl;
    for(int i = 0; i < n; i++) {
        cout << processes[i].pid << "\t" << processes[i].arrival_time << "\t\t" << processes[i].burst_time << "\t\t" << processes[i].priority << "\t\t" << processes[i].completion_time << "\t\t" << processes[i].turnaround_time << "\t\t" << processes[i].weighted_turnaround_time << endl;
    }

    return 0;
}

此代码使用了结构体来存储进程信息，使用了STL中的vector和sort函数来排序。在计算完成时间、周转时间和带权周转时间时，使用了一个变量current_time来记录当前时间。最后输出结果时，使用了制表符来对齐数据。

C++计算周转时间和带权周转时间，利用到达时间和优先数，时间片为1的最高优先数优先算法

以下是 C++ 实现最高优先数优先算法计算周转时间和带权周转时间的代码：

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

struct Process {
    int id;         // 进程 ID
    int arrival;    // 到达时间
    int burst;      // 执行时间
    int priority;   // 优先数
    int waiting;    // 等待时间
    int turnaround; // 周转时间
    float ratio;    // 带权周转时间比率
};

bool cmp(Process a, Process b) {
    return a.arrival < b.arrival;
}

void calculate(Process processes[], int n) {
    int time = 0;
    vector<Process> queue;

    // 按到达时间排序
    sort(processes, processes + n, cmp);

    // 执行最高优先数优先算法
    while (!queue.empty() || time < processes[0].arrival) {
        // 加入到达的进程
        while (processes[0].arrival <= time && processes[0].burst > 0) {
            processes[0].waiting = time - processes[0].arrival;
            queue.push_back(processes[0]);
            pop_heap(processes, processes + n, cmp);
            n--;
        }

        // 选取优先数最高的进程
        if (!queue.empty()) {
            sort(queue.begin(), queue.end(), [](Process a, Process b) {
                return a.priority > b.priority;
            });
            Process& p = queue[0];

            // 执行进程
            p.burst--;
            time++;

            // 计算周转时间
            if (p.burst == 0) {
                p.turnaround = time - p.arrival;
                p.ratio = (float)p.turnaround / p.waiting;
                queue.erase(queue.begin());
            }
        }
        else {
            time++;
        }
    }
}

int main() {
    int n;
    cout << "请输入进程数：";
    cin >> n;

    Process processes[n];
    for (int i = 0; i < n; i++) {
        processes[i].id = i + 1;
        cout << "请输入第 " << processes[i].id << " 个进程的到达时间、执行时间、优先数：";
        cin >> processes[i].arrival >> processes[i].burst >> processes[i].priority;
    }

    calculate(processes, n);

    cout << "进程编号\t到达时间\t执行时间\t优先数\t等待时间\t周转时间\t带权周转时间比率" << endl;
    for (int i = 0; i < n; i++) {
        cout << processes[i].id << "\t\t" << processes[i].arrival << "\t\t"
             << processes[i].burst << "\t\t" << processes[i].priority << "\t\t"
             << processes[i].waiting << "\t\t" << processes[i].turnaround << "\t\t"
             << processes[i].ratio << endl;
    }

    return 0;
}

该代码实现了输入进程的到达时间、执行时间和优先数，然后计算每个进程的等待时间、周转时间和带权周转时间比率，并输出结果表格。其中，最高优先数优先算法的实现采用了 STL 的 vector 和 heap 算法。