一、算法思想：

        高响应比优先调度算法（HRRN）是一种对CPU响应比的分配的一种算法。HRRN是介于FCFS（先来先服务算法）与SJF（短作业优先算法）之间的折中算法，既考虑作业等待时间又考虑作业运行时间，既照顾短作业又不使长作业等待时间过长，改进了调度性能。

 二、实现代码：

package Package8;

import java.util.Scanner;

/**
 * 高响应比优先调度
 */
public class HRRN {

    public static void main(String[] args) {

        PCB[] a = new PCB[10];

        // input方法用于输入进程信息，返回输入进程的总数
        int k = input(a);

        // 输出初始作业状态
        System.out.println("初始作业状态：");
        // 遍历输出数组
        output(a, k);


        // 找出最早到达的进程,优先调度
        PCB min = new PCB();
        min = a[0];
        int m = 0; // 用于记录最早到达进程的id（下标）
        for (int i = 0; i < k; i++) {

            if (a[i].getArriveTime() < min.getArriveTime()){
                min = a[i];
                m = i;
            } else if(a[i].getArriveTime() == min.getArriveTime() && a[i].getServiceTime() < min.getServiceTime()){
                min = a[i];
                m = i;
            }
        }
        PCB temp;
        temp = a[0];
        a[0] = min;
        a[m] = temp;


        System.out.println("调度过程：");
        // currentTime 用于记录当前时间（最后一个已经调度的作业的完成时间）
        double currentTime = 0;
        // 当该进程最早到达时，直接调度
        a[0].setCondition(1); // 调度进程，将进程状态改为运行
        a[0].setFinishTime(a[0].getArriveTime() + a[0].getServiceTime());
        a[0].setCyclingTime(a[0].getFinishTime() - a[0].getArriveTime());
        // 将结果保留两位小数
        double time = a[0].getCyclingTime() / a[0].getServiceTime();
        a[0].setFloat_Wi(Double.parseDouble(String .format("%.2f", time)));
        output(a,k); // 遍历数组
        a[0].setCondition(2); // 进程调度完毕，将进程状态改为完成
        // 记录当前时间
        currentTime = a[0].getFinishTime();

        for (int i = 1; i < k; i++) {
            for (int j = i; j < k; j++) {

                    if (currentTime - a[j].getArriveTime() < 0){
                        a[j].setWaitTime(0);
                    } else {
                        a[j].setWaitTime(currentTime - a[j].getArriveTime());
                    }
                    a[j].setDibs((a[j].getWaitTime()/a[j].getServiceTime()) + 1);

            }


            // 找出优先权最大的进程，放到第i个位置，直接调度
            PCB max;
            max = a[0]; // a[0]的优先级默认为0
            int n = 0; // 用于当前优先权最大进程的id（下标）
            for (int x = i; x < k; x++) {
                if (a[x].getDibs() > max.getDibs()){
                    max = a[x];
                    n = x;
                } else if (a[x].getDibs() == max.getDibs() && a[x].getArriveTime() < max.getArriveTime()){
                    max = a[x];
                    n = x;
                }
            }
            temp = a[i];
            a[i] = max;
            a[n] = temp;

            // 调度第i个进程
            a[i].setCondition(1);
            output(a,k);
            if (a[i].getArriveTime() > a[i - 1].getFinishTime()){
                a[i].setFinishTime(a[i].getArriveTime() + a[i].getServiceTime());

            } else{

                a[i].setFinishTime(a[i - 1].getFinishTime() + a[i].getServiceTime());
            }
            a[i].setCyclingTime(a[i].getFinishTime() - a[i].getArriveTime());

            // 将结果保留两位小数
            time = a[i].getCyclingTime() / a[i].getServiceTime();
            a[i].setFloat_Wi(Double.parseDouble(String .format("%.2f", time)));
            a[i].setCondition(2);
            // 记录当前时间
            currentTime = a[i].getFinishTime();


        // 一轮循环结束，进入下一轮循环
        }

        // 遍历输出数组
        System.out.println("调度后作业状态：");
        output(a, k);

    }

    /**
     * 该方法用于遍历输出数组
     * @param a
     * @param k
     */
    public static void output(PCB[] a, int k){
        for (int i = 0; i < k; i++) {
            System.out.println(a[i]);
            if (i == k - 1){
                System.out.println();
            }
        }
    }

    /**
     * 该方法用于输入进程信息
     * @param a
     * @return 输入进程的个数
     */
    public static int input(PCB[] a){

        Scanner scanner = new Scanner(System.in);

        int k = 0; // 初始化,k记录总进程数
        System.out.println("请一次输入两个整数，之间用空格隔开,输入负数结束输入");

        // 重复输入进程信息
        while (true){
            System.out.printf("请输入第%d进程到达时间、服务时间：", k);
            // 将进程id设置为k
            double arriveTime = scanner.nextDouble();
            if (arriveTime < 0){
                System.out.println("输入结束");
                break;
            }
            double serviceTime = scanner.nextDouble();
            a[k] = new PCB(k,arriveTime, serviceTime); // 利用构造方法初始化数据
            k ++;
            if (serviceTime < 0){
                System.out.println("输入结束");
                break;
            }
        }
        scanner.close(); // 释放scanner

        return k;
    }


    public static class PCB implements Package8.PCB {

        private int id;
        private double arriveTime; // 到达时间
        private double serviceTime; // 服务时间
        private double finishTime; // 完成时间
        private double cyclingTime; // 周转时间
        private double float_Wi; // 带权周转时间
        private double waitTime; // 等待时间
        private double dibs; // 优先权
        private int condition; // 进程状态，0表示等待，1表示运行，2表示完成

        public int getCondition() {
            return condition;
        }

        public void setCondition(int condition) {
            this.condition = condition;
        }

        public double getWaitTime() {
            return waitTime;
        }

        public void setWaitTime(double waitTime) {
            this.waitTime = waitTime;
        }

        public double getDibs() {
            return dibs;
        }

        public void setDibs(double dibs) {
            this.dibs = dibs;
        }

        public int getId() {
            return id;
        }

        public void setId(int id) {
            this.id = id;
        }

        public double getArriveTime() {
            return arriveTime;
        }

        public void setArriveTime(double arriveTime) {
            this.arriveTime = arriveTime;
        }

        public double getServiceTime() {
            return serviceTime;
        }

        public void setServiceTime(double serviceTime) {
            this.serviceTime = serviceTime;
        }

        public double getFinishTime() {
            return finishTime;
        }

        public void setFinishTime(double finishTime) {
            this.finishTime = finishTime;
        }

        public double getCyclingTime() {
            return cyclingTime;
        }

        public void setCyclingTime(double cyclingTime) {
            this.cyclingTime = cyclingTime;
        }

        public double getFloat_Wi() {
            return float_Wi;
        }

        public void setFloat_Wi(double float_Wi) {
            this.float_Wi = float_Wi;
        }

        public PCB() {
        }

        public PCB(int id, double arriveTime, double serviceTime) {
            this.id = id;
            this.arriveTime = arriveTime;
            this.serviceTime = serviceTime;
        }

        @Override
        public String toString() {
            String condition1;
            if (condition == 2){
                condition1 = "完成";
                return "进程信息：" +
                        "id=" + id +
                        ", 到达时间=" + arriveTime +
                        ", 服务时间=" + serviceTime +
                        ", 完成时间=" + finishTime +
                        ", 周转时间=" + cyclingTime +
                        ", 带权周转时间=" + float_Wi +
                        ", 进程状态：" + condition1;
            } else {
                if (condition == 1){
                    condition1 = "运行";
                } else {
                    condition1 = "等待";
                }

                return "进程信息：" +
                        "id=" + id +
                        ", 到达时间=" + arriveTime +
                        ", 服务时间=" + serviceTime +
                        ", 完成时间=" + finishTime +
                        ", 周转时间=" + cyclingTime +
                        ", 带权周转时间=" + float_Wi +
                        ", 进程状态：" + condition1 +
                        ", 进程优先权：" + dibs;
            }
        }

    }
}

三、运行结果： 

高响应比优先算法

算法思想

响应比算法：(服务时间+等待时间)/服务时间
先将作业按到达时间排序，并将条件最优的作业移动到第一位，之后每次调度作业都更新后面所有作业的响应比，并将最高的响应比往前移。

#include<iostream>
#include<iomanip>
#include<string.h>
using namespace std;
struct work{
	char name[20];//作业名 
	float arrive;//到达时间 
	float service;//服务时间 
	float finish;//完成时间 
	float T;//周转时间 
	float W;//带权周转时间 
	float waitTime;//等待时间 
	float H;//相应比 
};

int main(){
	int n;//作业数 
	struct work z[20];
	cin>>n;
	for(int i=0;i<n;i++){
		cin>>z[i].name;	
	}
	
	for(int i=0;i<n;i++){
		cin>>z[i].arrive;
	}
	
	for(int i=0;i<n;i++){
		cin>>z[i].service;
	}
	
	struct work a=z[0];//用一个结构体存储z[0]或条件最优的作业的值 
	int min=0;//最优条件的作业的位置 
	for(int i=1;i<n;i++){
		if(a.arrive>=z[i].arrive&&a.service>z[i].service){//判断条件更小或相等的到达时间且更短的服务时间 
			a=z[i];
			min=i;
		}
	}
	swap(z[0],z[min]);//将条件最优作业换到z[0]位置 
	
	//从z[1]位置开始按到达时间从小到大排序 
	for(int i=1;i<n-1;i++){
		for(int j=i+1;j<n;j++){
			if(z[i].arrive>z[j].arrive)
			swap(z[i],z[j]);
		}
	}
	
	//计算完成时间
	z[0].finish=z[0].arrive+z[0].service;
	for(int i=1;i<n-1;i++){	
		if(z[i-1].finish<z[i].arrive){//判断条件当前到达时间大于上个完成时间 
			z[i].finish=z[i].arrive+z[i].service;//改变完成时间算法 
			continue;//继续下一个循环 
		}
		
		//从i开始每次循环更新等待时间和相应比 
		for(int l=i;l<n;l++){
			z[l].waitTime=z[i-1].finish-z[l].arrive;
			z[l].H=(z[l].service+z[l].waitTime)/z[l].service;
		}
		
		//从i+1开始将更优作业往前移 
		for(int j=i+1;j<n;j++){
			if(z[j].arrive<=z[i-1].finish&&z[j].H>z[i].H){//判断条件到达时间更小或相等且响应比更大的作业
				swap(z[i],z[j]);
				for(int k=j;k>i+1;k--){
					if(z[k].arrive<z[k-1].arrive){
						swap(z[k],z[k-1]);
					}
					else{
						break;
					}
				}
			}
		}
		
		//按不同情况计算完成时间 
		if(z[i].arrive>z[i-1].finish){
			z[i].finish=z[i].arrive+z[i].service;
		}
		else{
			z[i].finish=z[i-1].finish+z[i].service;
		}
		
		//最后两个作业改变计算方式 
		if(i==n-2){
			if(z[i+1].arrive>z[i].finish){
				z[i+1].finish=z[i+1].arrive+z[i+1].service;
			}
			else{
				z[i+1].finish=z[i].finish+z[i+1].service;
			}	
		}
	} 
	
	//计算周转时间和带权周转时间 
	for(int i=0;i<n;i++){
		z[i].T=z[i].finish-z[i].arrive;
		z[i].W=z[i].T/z[i].service;
	}
	
	for(int i=1;i<n-1;i++){
		for(int j=i+1;j<n;j++){
			if(z[i].arrive>z[j].arrive)
			swap(z[i],z[j]);
		}
	}
	
	cout<<"作 业 名：";
	for(int i=0;i<n;i++){
		cout<<z[i].name;
		if(i!=n-1)
		cout<<" ";
	}
	cout<<endl;
		
	cout<<"到达时间：";
	for(int i=0;i<n;i++){
		cout<<z[i].arrive;
		if(i!=n-1)
		cout<<" ";
	}
	cout<<endl;
		
	cout<<"服务时间：";
	for(int i=0;i<n;i++){
		cout<<z[i].service;
		if(i!=n-1)
		cout<<" ";
	}
	cout<<endl;
		
	cout<<"完成时间：";
	for(int i=0;i<n;i++){
		cout<<z[i].finish;
		if(i!=n-1)
		cout<<" ";
	}
	cout<<endl;
		
	cout<<"周转时间：";
	for(int i=0;i<n;i++){
		cout<<z[i].T;
		if(i!=n-1)
		cout<<" ";
	}
	cout<<endl;
		
	cout<<"带权周转时间：";
	for(int i=0;i<n;i++){
		cout<<fixed<<setprecision(2)<<z[i].W;
		if(i!=n-1)
		cout<<" ";
	}
	cout<<endl;
	
	return 0;
}

高响应比优先HRRN

高响应比优先调度算法主要用于作业调度，该算法是对FCFS调度算法和SJF调度算法的一种综合平衡，同时考虑每个作业的等待时间和估计的运行时间。在每次进行作业调度时，先计算后备作业队列中每个作业的响应比，从中选出响应比最高的作业投入运行。

响应比的变化规律可描述为：

响应比=（等待时间+服务时间）/服务时间

根据公式可知：

当作业的等待时间相同时，则要求服务时间越短，其响应比越高，有利于短作业。

当要求服务时间相同时，作业的响应比由其等待时间决定，等待时间越长，其响应比越高，因而它实现的是先来先服务。

对于长作业，作业的响应比可以随等待时间的增加而提高，当其等待时间足够长时，其响应比便可升到很高，从而也可获得处理机。克服了饥饿状态，兼顾了长作业。

参考文章：
1、操作系统中调度算法（FCFS、RR、SPN、SRT、HRRN）
2、高响应比优先调度算法（HRRN）例题详解