操作系统 高响应比优先算法 （C++实现 操作系统实验）

高响应比优先算法思想：

每个进程执行完，都会对就绪队列中的进程进行响应比从高到低计算并排序。（因为是非抢占式）

第一个到达的进程一定是先执行，并直到执行完毕。

代码如下：

#include<iostream>
#include<queue>
#include<algorithm>
#include<string>
#include<vector>
#include<map>
using namespace std;
struct shuxing{
	char name;
	double arriveTime;
	double serviceTime; 
	double priority;
	friend bool operator<(shuxing n1,shuxing n2){ // 自定义比较函数 
		 if(n1.priority != n2.priority)
		 return n1.priority < n2.priority;  // 优先按响应比从高到低排序
		 else
		 return n1.arriveTime > n2.arriveTime; // 当响应比一样时，按到达时间从低到高排序
	}
};

priority_queue<shuxing, vector<shuxing>, less<shuxing> > jincheng; 
// priority_queue less: from large to small
priority_queue<shuxing, vector<shuxing>, less<shuxing> > mirror;

vector<char> seq; // 存进程调度的顺序 
vector<double> ks; // 存开始时间 
vector<double> wc;	//存完成时间 
vector<double> zz;	// 存周转时间 
vector<double> dqzz;	// 存带权周转时间 

double avezz, avedqzz;  // 平均周转时间和平均带权周转时间 

int n;  // 进程的数量 

int main() {	
	
	cout << "请输入进程的数量：" << "\n";
	cin >> n;
	
	char x;
	double y, z;
	for(int i = 0; i < n; i ++) {
		cout << "请输入第" << i + 1 << "个进程的名字，到达时间，服务时间 <例如：A,2,1>：" << "\n";
		cin >> x >> y >> z;
		shuxing temp;
		temp.name = x;
		temp.arriveTime = y;
		temp.serviceTime = z;
		temp.priority = -1;   // 一开始响应比都设置为-1，所以在队列中会按到达时间排序
		jincheng.push(temp);
	}
	
	int k = jincheng.top().arriveTime;  
// k代表当前时间，一开始的时间设置为最先到达的进程的到达时间
	
	while(!jincheng.empty()) {  // 优先队列模拟 
		shuxing temp = jincheng.top();  
 // 队列中第一个是响应比最高的，或者是第一个到达的进程，出队执行
		jincheng.pop();
		seq.push_back(temp.name);
		ks.push_back(k);
		k += temp.serviceTime;
		wc.push_back(k);
		zz.push_back(k - temp.arriveTime);
		avezz += (k - temp.arriveTime);
		dqzz.push_back((k - temp.arriveTime) / temp.serviceTime);
		avedqzz += ((k - temp.arriveTime) / temp.serviceTime);
		
		while(!jincheng.empty()) {   // 先将进程暂存到mirror队列中
			shuxing temp1 = jincheng.top();
			jincheng.pop();
			mirror.push(temp1);    
		}
		while(!mirror.empty()) {
			if(mirror.top().arriveTime <= k) {  // 进程已经到达时
				shuxing temp2 = mirror.top();
				mirror.pop();
				temp2.priority = (k - temp2.arriveTime + temp2.serviceTime) / temp2.serviceTime; 
                // 对进程的响应比进行计算
				jincheng.push(temp2);   // 放入优先队列自动按响应比排序
			}
			else {                               // 进程未到达
				shuxing temp3 = mirror.top();
				mirror.pop();
				jincheng.push(temp3);  // 也放入优先队列，响应比肯定是-1
			}
		}
	}	
	
	cout << "\n执行顺序：\t";	
	for(int i = 0; i < n; i ++)
		cout << seq[i] << "\t"; 
		cout << "\n";
	
	cout << "\n开始时间：\t";
	for(int i = 0; i < n; i ++)
		cout << ks[i] << "\t";
		cout << "\n";
	 
	cout << "\n完成时间：\t";
	for(int i = 0; i < n; i ++)
		cout << wc[i] << "\t";
		cout << "\n";	

	cout << "\n周转时间：\t";
	for(int i = 0; i < n; i ++) 
		cout << zz[i] << "\t"; 
		cout << "\n";
		
	cout << "\n带权周转时间：\t";
	for(int i = 0; i < n; i ++)
		printf("%.2lf\t", dqzz[i]);
		cout << "\n";
		
	cout << "\n平均周转时间：";
	printf("\t\t%.2lf\n", avezz / n);
	
	cout << "\n平均带权周转时间：";
	printf("\t%.2lf", avedqzz / n);

	return 0;
}