# 操作系统HRRF算法，数组实现。

一、准备阶段

先开始有四个作业1、2、3、4。

序号	作业到达时间	所需CPU运行时间
1	0	120
2	50	50
3	60	10
4	110	20

二、设想路线

1、设置等待时间是为了计算响应比。

响应比=1+作业已等待时间/cpu运行时间

2、设置已运行时间，其实没有太大作用，但是SRTF用处很大这里也就加了。 3、设置开始时刻。

序号	作业到达时间	所需CPU运行时间	等待时间	已运行时间	开始时刻	结束时刻
1	0	120	0	0	-1	-1
2	50	50	0	0	-1	-1
3	60	10	0	0	-1	-1
4	110	20	0	0	-1	-1

代码实现部分

一、写出主函数

main() 包含数组a

#include<stdio.h>
#define m 4
#define n 7
int main()
{
    int a[m][n]={{1,  0, 120, 0, 0, -1, -1},

                 {2, 50,  50, 0, 0, -1, -1},

                 {3, 60,  10, 0, 0, -1, -1},

                 {4,110,  20, 0, 0, -1, -1},

                };

    shuchu(a);
    hrrf(a);
}

二、输出函数

shuchu()

void shuchu(int b[m][n])
{
    int i,j;
    printf("\n序号\t到达时间\t所需cpu运行时间\t等待时间\t已运行时间\t开始时刻\t结束时刻\n");
    for ( i = 0; i < m; i++)
    {
        if (i!=0)
            printf("\n");
        //printf("%d",i+1);
        for ( j = 0; j < n; j++)
            printf("%4d",b[i][j]);
    }
}

三、算法实现部分

void hrrf(int b[m][n])
{
    int num=m;//作业总数
    int time_sys=0;//系统当前时间
    float max_xyb=-1;//最大响应比
    int current=0;//当前进程号
    int ZhouZhuan[m];//保存作业周转时间
    float xyb_i=0;//每个作业响应比
    float T=0,t=0;
    int j;  
    while (num>0)
    {
        int i  ;
        for (i=1;i<=4;i++)
        {
            if((time_sys>=b[i-1][1])&&(b[i-1][4]<b[i-1][2]))
            /*已经提交，且未结束*/
            {
                xyb_i=1+(float)((time_sys-b[i-1][1])/(float)(b[i-1][2]));//响应比=1+等待时间/作业所需cpu运行时间；等待时间=系统当前时间-到达时间
                if (xyb_i>max_xyb)
                {
                    current=i;
                    max_xyb=xyb_i;//更新最大响应比
                }
            }
        }        printf("\n\nselect:%d,systime:%d",current,time_sys);//输出最大响应比作业号
        b[current-1][5]=time_sys;        //该current作业开始运行，保存开始时刻
        b[current-1][4]+=b[current-1][2];//已运行时间=已运行+所需cpu运行时间
        time_sys+=b[current-1][2];       //更新系统时间，因为是不抢占式的
        b[current-1][6]=time_sys;        //保存作业完成结束时间
        num=num-1;                       //作业数减1
        max_xyb=-1;                      //最高响应比赋初值，重新比
        ZhouZhuan[current-1]=b[current-1][6]-b[current-1][1];//保存周转时间
        for ( i = 0; i < num; i++)        //其他作业因占用cpu而出现等待
        {
            if (i!=(current-1)&&b[i][4]<b[i][2])
            {
                b[i][3]=time_sys-b[i][1];//更新其他作业等待时间
            }
        }
    shuchu(b);    
    }
    for(j=0;j<m;j++)
    {
        T+=ZhouZhuan[j];
        t+=ZhouZhuan[j]/b[j][2]; 
    }
    T=T/m;
    printf("\n平均周转时间T=%.2fms",T);
    t=t/m;
    printf("\n平均带权周转时间t=%.2fms",t);
}

while内循环

首先

第一个while，if 该作业已经提交且未结束(i=1)

num	time_sys(系统时间)	max_xyb（最大响应比）	current（当前进程号）	max_xyb
4	0	-1(1)	0	-1(1)
i+=1;i为1、2、3，此时time_sys系统时间为0，剩下三个作业都未到，自然最大响应比也不会变。

接下来

只运行第一个作业： 运行最后一个for循环，更新他们此时的等待时间。

序号	作业到达时间	所需CPU运行时间	等待时间	已运行时间	开始时刻	结束时刻
1	0	120	0	120	0	120
2	50	50	0	70	-1	-1
3	60	10	0	60	-1	-1
4	110	20	0	10	-1	-1
这些值也会改变：
num	time_sys(系统时间)	max_xyb（最大响应比）	current（当前进程号）	max_xyb
---	------------------	---------------------	---------------------	-------
3	120	-1	0 (1)	-1（赋初值了）

最后

就是最外层whlie依次循环了。