使用c++编程实现进程调度算法中的高响应比优先调度算法定义多个进输出本次调度过程的评价指标：各进程的周转时间和带权周转时间、平 均周转时间和带权周转时间、处理机空闲时间。程并建立就绪队列

好的，下面是使用C++编程实现高响应比优先调度算法的代码：

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

struct Process {
    int pid; // 进程ID
    int arrivalTime; // 到达时间
    int burstTime; // 执行时间
    int responseRatio; // 响应比
    int waitingTime; // 等待时间
    int turnaroundTime; // 周转时间
    int finishTime; // 完成时间
};

// 比较函数，按到达时间从小到大排序
bool compareArrivalTime(Process p1, Process p2) {
    return p1.arrivalTime < p2.arrivalTime;
}

// 比较函数，按响应比从大到小排序
bool compareResponseRatio(Process p1, Process p2) {
    return p1.responseRatio > p2.responseRatio;
}

// 计算各项指标
void calculate(Process p[], int n) {
    int totalWaitingTime = 0, totalTurnaroundTime = 0, totalResponseRatio = 0, idleTime = 0;
    for (int i = 0; i < n; i++) {
        totalWaitingTime += p[i].waitingTime;
        totalTurnaroundTime += p[i].turnaroundTime;
        totalResponseRatio += p[i].responseRatio;
        if (i == 0) {
            idleTime += p[i].arrivalTime;
        } else {
            idleTime += p[i].arrivalTime - p[i - 1].finishTime;
        }
    }
    cout << "平均等待时间：" << totalWaitingTime * 1.0 / n << endl;
    cout << "平均周转时间：" << totalTurnaroundTime * 1.0 / n << endl;
    cout << "平均带权周转时间：" << totalResponseRatio * 1.0 / n << endl;
    cout << "处理机空闲时间：" << idleTime << endl;
}

int main() {
    int n; // 进程数量
    cout << "请输入进程数量：";
    cin >> n;
    Process p[n]; // 进程数组
    queue<Process> readyQueue; // 就绪队列
    for (int i = 0; i < n; i++) {
        p[i].pid = i + 1;
        cout << "请输入第" << i + 1 << "个进程的到达时间和执行时间：";
        cin >> p[i].arrivalTime >> p[i].burstTime;
        p[i].responseRatio = 0;
        p[i].waitingTime = 0;
        p[i].turnaroundTime = 0;
        p[i].finishTime = 0;
    }

    sort(p, p + n, compareArrivalTime); // 按到达时间排序

    int currentTime = p[0].arrivalTime; // 当前时间初始化为第一个进程的到达时间
    int completed = 0; // 已完成的进程数量

    while (completed < n) {
        // 将已到达的进程加入就绪队列
        while (p[0].arrivalTime <= currentTime && completed < n) {
            readyQueue.push(p[0]);
            for (int i = 0; i < n - 1; i++) {
                p[i] = p[i + 1];
            }
            p[n - 1].arrivalTime = INT_MAX; // 最后一个进程到达时间设为无穷大
            sort(p, p + n - 1, compareArrivalTime); // 按到达时间排序
            completed++;
        }

        if (!readyQueue.empty()) {
            // 计算响应比
            for (int i = 0; i < readyQueue.size(); i++) {
                Process temp = readyQueue.front();
                readyQueue.pop();
                temp.responseRatio = (temp.waitingTime + temp.burstTime) * 1.0 / temp.burstTime;
                readyQueue.push(temp);
            }

            // 按响应比排序
            vector<Process> temp;
            while (!readyQueue.empty()) {
                temp.push_back(readyQueue.front());
                readyQueue.pop();
            }
            sort(temp.begin(), temp.end(), compareResponseRatio);
            for (int i = 0; i < temp.size(); i++) {
                readyQueue.push(temp[i]);
            }

            // 执行当前进程
            Process currentProcess = readyQueue.front();
            readyQueue.pop();
            currentProcess.waitingTime = currentTime - currentProcess.arrivalTime;
            currentProcess.turnaroundTime = currentProcess.waitingTime + currentProcess.burstTime;
            currentProcess.finishTime = currentTime + currentProcess.burstTime;
            currentTime = currentProcess.finishTime;

            // 更新进程数组
            for (int i = 0; i < n; i++) {
                if (p[i].pid == currentProcess.pid) {
                    p[i] = currentProcess;
                    break;
                }
            }
        } else {
            currentTime++; // 处理机空闲
        }
    }

    // 输出各项指标
    calculate(p, n);

    return 0;
}

在程序中，先定义了一个结构体`Process`，表示进程信息。其中，`pid`表示进程ID，`arrivalTime`表示到达时间，`burstTime`表示执行时间，`responseRatio`表示响应比，`waitingTime`表示等待时间，`turnaroundTime`表示周转时间，`finishTime`表示完成时间。

然后，定义了两个比较函数，分别用于按到达时间从小到大排序和按响应比从大到小排序。

接着，输入进程信息，并按到达时间从小到大排序。然后，按照高响应比优先调度算法的流程进行调度，直到所有进程都执行完毕。在计算各项指标时，根据公式计算出各项指标的值，并输出到控制台。

最后，输出各项指标。