非剥夺式HPF算法

题目1：进程调度1—静态非剥夺式优先级调度计算平均作业周转时间

问题描述：要求输入3个进程的信息，假设这些进程均是在0时刻同时到达，若进程调度采用非剥夺式静态优先级（优先数数值大的表示优先级比较高；如果遇到优先级一样，按照输入顺序执行。），计算并输出平均作业周转时间。

输入格式：程序要求输入3行，以回车符号作为分隔，每行有3个数据，以空格作为分隔。首先输入一个字符串（长度小于等于10），为进程名，第2个数据类型为整型，表示进程的优先数，第3个数据类型为整型，表示进程的运行时间。

输出格式：输出结果为一个浮点数，保留到小数点后一位，为系统的平均作业周转时间。

样例输入1：
P1 1 1
P2 2 2
P3 3 3
样例输出1：
4.7

样例输入2：
P1 10 10
P2 100 100
P3 100 100
样例输出2：
170.0

C语言：

#include <stdio.h>

struct PROCESS{
    char process_name[10];
    int arrive;
    int runtime;
    int waittime;
    float respons;
    int flag;

};
int main(){
    struct PROCESS process[3];
    int i, j;
    for(i=0;i<3;i++){
        scanf("%s %d %d",&process[i].process_name,&process[i].arrive,&process[i].runtime);
        process[i].flag = i+1;
    }
    for (i = 0; i < 3-i; i++){
        for (j = 0; j < 3 - i - 1; j++) {
            struct PROCESS temp;
            if (process[j + 1].priority > process[j].priority) {
                temp = process[j];
                process[j] = process[j + 1];
                process[j + 1] = temp;
            }
        }
    }
    for(i=0;i<3;i++){
        int time = 0;
        if(i==0){
            time += process[0].runtime;
        }else if(i==1){
            time += process[0].runtime + process[1].runtime;
        }else{
            time += process[0].runtime + process[1].runtime + process[2].runtime;
        }
        avg_time += time;
    }
    avg_time = avg_time/3;
    printf("%.1f",avg_time);



    return 0;
}

java：

public class HPF {
   String name;
   int level;
   int servicetime;
   int starttime;
   int arrivetime = 0;
   int finishtime;
   int zztime = 0; //周转时间

   public HPF() {
   }

   public HPF(String name, int level, int servicetime) {
      this.name = name;
      this.level = level;
      this.servicetime = servicetime;

   }


   //主方法
   public static void main(String[] args) {
      Scanner scanner = new Scanner(System.in);

      //创建进程数组对象
      HPF[] p = new HPF[3];
      for (int i = 0; i < p.length; i++) {
         p[i] = new HPF(scanner.next(), scanner.nextInt(), scanner.nextInt());
      }
      OS_HPF(p); //调用进程优先级算法
      scanner.close();
   }


   //进程优先级算法
   private static void OS_HPF(HPF[] p) {
      sort(p);
      run(p);

      double alltime = 0;
      for (int k = 0; k < p.length; k++) {
         alltime += p[k].zztime;
      }
      alltime = alltime / p.length;
      System.out.printf("%.1f",alltime);
      System.out.println();

   }

   //排序算法(冒泡排序法)
   public static void sort(HPF[] p) {
      for (int i = 0; i < p.length-i; i++) {
         for (int j = 0; j < p.length-i-1; j++) {
            HPF temp;
            if (p[j+1].level > p[j].level) {
               temp = p[j];
               p[j] = p[j+1];
               p[j+1] = temp;
            }
         }
      }
   }


   //进程执行
   private static void run(HPF[] p) {
      for (int k = 0; k < p.length; k++) {
         if (k == 0) {
            p[k].starttime = p[k].arrivetime;
            p[k].finishtime = p[k].arrivetime + p[k].servicetime;
         } else {
            p[k].starttime = p[k - 1].finishtime;
            p[k].finishtime = p[k - 1].finishtime + p[k].servicetime;
         }
         p[k].zztime = p[k].finishtime - p[k].arrivetime;  //计算该进程周转时间
      }
   }