zoukankan      html  css  js  c++  java
  • 实验三 进程调度模拟程序

    实验三 进程调度模拟程序

    1.    目的和要求

    1.1.           实验目的

    用高级语言完成一个进程调度程序,以加深对进程的概念及进程调度算法的理解。

    1.2.           实验要求

    1.2.1例题:设计一个有 N个进程并发执行的进程调度模拟程序。

    进程调度算法:采用最高优先级优先的调度算法(即把处理机分配给优先级最高的进程)和先来先服务(若优先级相同)算法。

    (1).  每个进程有一个进程控制块(PCB)表示。进程控制块包含如下信息:进程名、优先级、到达时间、需要运行时间、已用CPU时间、进程状态等等。

    (2).  进程的优先级及需要的运行时间可以事先人为地指定,进程的运行时间以时间片为单位进行计算。

    (3).  每个进程的状态可以是就绪 r(ready)、运行R(Running)、或完成F(Finished)三种状态之一。

    (4).  就绪进程获得 CPU后都只能运行一个时间片。用已占用CPU时间加1来表示。

    (5).  如果运行一个时间片后,进程的已占用 CPU时间已达到所需要的运行时间,则撤消该进程,如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间,也就是进程还需要继续运行,此时应将进程的优先数减1(即降低一级),然后把它插入就绪队列等待调度。

    (6).  每进行一次调度程序都打印一次运行进程、就绪队列中各个进程的 PCB,以便进行检查。   

    (7).  重复以上过程,直到所要进程都完成为止。

    思考:作业调度与进程调度的不同?

    1.2.2实验题A:编写并调试一个模拟的进程调度程序,采用“最高优先数优先”调度算法对N(N不小于5)个进程进行调度。

    “最高优先级优先”调度算法的基本思想是把CPU分配给就绪队列中优先数最高的进程。

    (1). 静态优先数是在创建进程时确定的,并在整个进程运行期间不再改变。

    (2). 动态优先数是指进程的优先数在创建进程时可以给定一个初始值,并且可以按一定规则修改优先数。例如:在进程获得一次CPU后就将其优先数减少1,并且进程等待的时间超过某一时限(2个时间片时间)时增加其优先数等。

    (3). (**)进程的优先数及需要的运行时间可以事先人为地指定,(也可以由随机数产生)。

    (4). (**)在进行模拟调度过程可以创建(增加)进程,其到达时间为进程输入的时间。

    0.

    1.2.3实验题B:编写并调试一个模拟的进程调度程序,采用“基于时间片轮转法”调度算法对N(N不小于5)个进程进行调度。 “轮转法”有简单轮转法、多级反馈队列调度算法。

    (1). 简单轮转法的基本思想是:所有就绪进程按 FCFS排成一个队列,总是把处理机分配给队首的进程,各进程占用CPU的时间片长度相同。如果运行进程用完它的时间片后还未完成,就把它送回到就绪队列的末尾,把处理机重新分配给队首的进程。直至所有的进程运行完毕。(此调度算法是否有优先级?)

     (2). 多级反馈队列调度算法的基本思想是:

    将就绪队列分为N级(N=3~5),每个就绪队列优先数不同并且分配给不同的时间片:队列级别越高,优先数越低,时间片越长;级别越小,优先数越高,时间片越短。

    系统从第一级调度,当第一级为空时,系统转向第二级队列,.....当处于运行态的进程用完一个时间片,若未完成则放弃CPU,进入下一级队列。

    当进程第一次就绪时,进入第一级队列。

    (3). (**)考虑进程的阻塞状态B(Blocked)增加阻塞队列。进程的是否阻塞和阻塞的时间由产生的“随机数”确定(阻塞的频率和时间长度要较为合理)。注意进程只有处于运行状态才可能转换成阻塞状态,进程只有处于就绪状态才可以转换成运行状态。

    2.    实验内容

    根据指定的实验课题:A(1),A(2),B(1)和B(2)

    完成设计、编码和调试工作,完成实验报告。

    注:带**号的条目表示选做内容。

    3.    实验环境

    可以选用Turbo C作为开发环境。也可以选用Windows下的VB,CB等可视化环境,利用各种控件较为方便。自主选择实验环境。

    4.    实验原理及核心算法参考程序段

         动态优先数(优先数只减不加):

            

      1 #include<sdio.h>
      2 #include<string.h>
      3 void shuru();
      4 void readfiles();
      5 void ran();
      6 void sort(int choose);//1为到达时间排序,2为服务时间排序,3为HRRF排序,4为优先级排序
      7 void FinishProcess();
      8 typedef struct Process
      9 {
     10     char name[10];
     11     char status;    //状态:开始s,等待d,就绪j
     12     int id;
     13     int arrtime;    //到达时间
     14     int reqtime;    //要求服务时间
     15     int startime;    //开始时间
     16     int finitime;    //完成时间
     17     int dotime;        //已经工作时间
     18 
     19     float TAtime,TAWtime;    //周转时间、带权周转时间
     20     float prio;        //优先级
     21     float HRRF;            //响应比
     22 
     23 }Process;
     24 
     25 
     26 Process Processes[100]; //最多100个作业
     27 int systime=0,bfsum,add,del;
     28 int intarr,infin,intjob,sumProcess;
     29 char T='A';              //T的默认值是A
     30 
     31 void RunProcess()
     32 {
     33     int i=1;
     34     sort(4);//按prio排序
     35     printf("
    ————开始运行————
    ");
     36     for(i=1;i<=sumProcess;i++)
     37     {
     38         printf("
    	Process %s	%f
    ",Processes[i].name,Processes[i].prio);
     39     }
     40     Processes[1].dotime++;
     41     if(Processes[1].dotime==Processes[1].reqtime)
     42     {
     43         FinishProcess();
     44     }
     45     Processes[1].prio--;
     46 }
     47 
     48 void FinishProcess()
     49 {
     50     int i,j;
     51     Process temp;
     52     for(i=1;i<=sumProcess;i++)
     53     {
     54         j=i-1;
     55                     strcpy(temp.name,Processes[i].name);
     56                     temp.status=Processes[i].status;
     57                     temp.arrtime=Processes[i].arrtime;
     58                     temp.reqtime=Processes[i].reqtime;
     59                     temp.startime=Processes[i].startime;
     60                     temp.finitime=Processes[i].finitime;
     61                     temp.TAtime=Processes[i].TAtime;
     62                     temp.TAWtime=Processes[i].TAWtime;
     63                     temp.prio=Processes[i].prio;
     64                     temp.id=Processes[i].id;
     65                     temp.HRRF=Processes[i].HRRF;
     66                     temp.dotime=Processes[i].dotime;
     67 
     68                     strcpy(Processes[i].name,Processes[j].name);
     69                     Processes[i].status=Processes[j].status;
     70                     Processes[i].arrtime=Processes[j].arrtime;
     71                     Processes[i].reqtime=Processes[j].reqtime;
     72                     Processes[i].startime=Processes[j].startime;
     73                     Processes[i].finitime=Processes[j].finitime;
     74                     Processes[i].TAtime=Processes[j].TAtime;
     75                     Processes[i].TAWtime=Processes[j].TAWtime;
     76                     Processes[i].prio=Processes[j].prio;
     77                     Processes[i].id=Processes[j].id;
     78                     Processes[i].HRRF=Processes[j].HRRF;
     79                     Processes[i].dotime=Processes[j].dotime;
     80 
     81                     strcpy(Processes[j].name,temp.name);
     82                     Processes[j].status=temp.status;
     83                     Processes[j].arrtime=temp.arrtime;
     84                     Processes[j].reqtime=temp.reqtime;
     85                     Processes[j].startime=temp.startime;
     86                     Processes[j].finitime=temp.finitime;
     87                     Processes[j].TAtime=temp.TAtime;
     88                     Processes[j].TAWtime=temp.TAWtime;
     89                     Processes[j].prio=temp.prio;
     90                     Processes[j].id=temp.id;
     91                     Processes[j].HRRF=temp.HRRF;
     92                     Processes[j].dotime=temp.dotime;
     93     }
     94     sumProcess--;
     95 }
     96 
     97 
     98 
     99 void sort(int choose)  //排序
    100 {
    101     int i,j;
    102     Process temp;
    103     for(i=1;i<=sumProcess;i++)
    104     {
    105         for(j=i+1;j<=sumProcess;j++)
    106         {
    107             if(choose==1)
    108             {
    109                 if(Processes[i].arrtime>Processes[j].arrtime)
    110                 {
    111                     strcpy(temp.name,Processes[i].name);
    112                     temp.status=Processes[i].status;
    113                     temp.arrtime=Processes[i].arrtime;
    114                     temp.reqtime=Processes[i].reqtime;
    115                     temp.startime=Processes[i].startime;
    116                     temp.finitime=Processes[i].finitime;
    117                     temp.TAtime=Processes[i].TAtime;
    118                     temp.TAWtime=Processes[i].TAWtime;
    119                     temp.prio=Processes[i].prio;
    120                     temp.id=Processes[i].id;
    121                     temp.HRRF=Processes[i].HRRF;
    122                     temp.dotime=Processes[i].dotime;
    123 
    124                     strcpy(Processes[i].name,Processes[j].name);
    125                     Processes[i].status=Processes[j].status;
    126                     Processes[i].arrtime=Processes[j].arrtime;
    127                     Processes[i].reqtime=Processes[j].reqtime;
    128                     Processes[i].startime=Processes[j].startime;
    129                     Processes[i].finitime=Processes[j].finitime;
    130                     Processes[i].TAtime=Processes[j].TAtime;
    131                     Processes[i].TAWtime=Processes[j].TAWtime;
    132                     Processes[i].prio=Processes[j].prio;
    133                     Processes[i].id=Processes[j].id;
    134                     Processes[i].HRRF=Processes[j].HRRF;
    135                     Processes[i].dotime=Processes[j].dotime;
    136 
    137                     strcpy(Processes[j].name,temp.name);
    138                     Processes[j].status=temp.status;
    139                     Processes[j].arrtime=temp.arrtime;
    140                     Processes[j].reqtime=temp.reqtime;
    141                     Processes[j].startime=temp.startime;
    142                     Processes[j].finitime=temp.finitime;
    143                     Processes[j].TAtime=temp.TAtime;
    144                     Processes[j].TAWtime=temp.TAWtime;
    145                     Processes[j].prio=temp.prio;
    146                     Processes[j].id=temp.id;
    147                     Processes[j].HRRF=temp.HRRF;
    148                     Processes[j].dotime=temp.dotime;
    149                 }
    150             }
    151             else if(choose==2)
    152             {
    153                 if(Processes[i].reqtime>Processes[j].reqtime)
    154                 {
    155                     strcpy(temp.name,Processes[i].name);
    156                     temp.status=Processes[i].status;
    157                     temp.arrtime=Processes[i].arrtime;
    158                     temp.reqtime=Processes[i].reqtime;
    159                     temp.startime=Processes[i].startime;
    160                     temp.finitime=Processes[i].finitime;
    161                     temp.TAtime=Processes[i].TAtime;
    162                     temp.TAWtime=Processes[i].TAWtime;
    163                     temp.prio=Processes[i].prio;
    164                     temp.id=Processes[i].id;
    165                     temp.HRRF=Processes[i].HRRF;
    166                     temp.dotime=Processes[i].dotime;
    167 
    168                     strcpy(Processes[i].name,Processes[j].name);
    169                     Processes[i].status=Processes[j].status;
    170                     Processes[i].arrtime=Processes[j].arrtime;
    171                     Processes[i].reqtime=Processes[j].reqtime;
    172                     Processes[i].startime=Processes[j].startime;
    173                     Processes[i].finitime=Processes[j].finitime;
    174                     Processes[i].TAtime=Processes[j].TAtime;
    175                     Processes[i].TAWtime=Processes[j].TAWtime;
    176                     Processes[i].prio=Processes[j].prio;
    177                     Processes[i].id=Processes[j].id;
    178                     Processes[i].HRRF=Processes[j].HRRF;
    179                     Processes[i].dotime=Processes[j].dotime;
    180 
    181                     strcpy(Processes[j].name,temp.name);
    182                     Processes[j].status=temp.status;
    183                     Processes[j].arrtime=temp.arrtime;
    184                     Processes[j].reqtime=temp.reqtime;
    185                     Processes[j].startime=temp.startime;
    186                     Processes[j].finitime=temp.finitime;
    187                     Processes[j].TAtime=temp.TAtime;
    188                     Processes[j].TAWtime=temp.TAWtime;
    189                     Processes[j].prio=temp.prio;
    190                     Processes[j].id=temp.id;
    191                     Processes[j].HRRF=temp.HRRF;
    192                     Processes[j].dotime=temp.dotime;
    193                 }
    194             }
    195             else if(choose==3)
    196             {
    197                 if(Processes[i].HRRF<Processes[j].HRRF)
    198                 {
    199                     strcpy(temp.name,Processes[i].name);
    200                     temp.status=Processes[i].status;
    201                     temp.arrtime=Processes[i].arrtime;
    202                     temp.reqtime=Processes[i].reqtime;
    203                     temp.startime=Processes[i].startime;
    204                     temp.finitime=Processes[i].finitime;
    205                     temp.TAtime=Processes[i].TAtime;
    206                     temp.TAWtime=Processes[i].TAWtime;
    207                     temp.prio=Processes[i].prio;
    208                     temp.id=Processes[i].id;
    209                     temp.HRRF=Processes[i].HRRF;
    210                     temp.dotime=Processes[i].dotime;
    211 
    212                     strcpy(Processes[i].name,Processes[j].name);
    213                     Processes[i].status=Processes[j].status;
    214                     Processes[i].arrtime=Processes[j].arrtime;
    215                     Processes[i].reqtime=Processes[j].reqtime;
    216                     Processes[i].startime=Processes[j].startime;
    217                     Processes[i].finitime=Processes[j].finitime;
    218                     Processes[i].TAtime=Processes[j].TAtime;
    219                     Processes[i].TAWtime=Processes[j].TAWtime;
    220                     Processes[i].prio=Processes[j].prio;
    221                     Processes[i].id=Processes[j].id;
    222                     Processes[i].HRRF=Processes[j].HRRF;
    223                     Processes[i].dotime=Processes[j].dotime;
    224 
    225                     strcpy(Processes[j].name,temp.name);
    226                     Processes[j].status=temp.status;
    227                     Processes[j].arrtime=temp.arrtime;
    228                     Processes[j].reqtime=temp.reqtime;
    229                     Processes[j].startime=temp.startime;
    230                     Processes[j].finitime=temp.finitime;
    231                     Processes[j].TAtime=temp.TAtime;
    232                     Processes[j].TAWtime=temp.TAWtime;
    233                     Processes[j].prio=temp.prio;
    234                     Processes[j].id=temp.id;
    235                     Processes[j].HRRF=temp.HRRF;
    236                     Processes[j].dotime=temp.dotime;
    237                 }
    238             }
    239             else if(choose==4)
    240             {
    241                 if(Processes[i].prio<Processes[j].prio)
    242                 {
    243                     strcpy(temp.name,Processes[i].name);
    244                     temp.status=Processes[i].status;
    245                     temp.arrtime=Processes[i].arrtime;
    246                     temp.reqtime=Processes[i].reqtime;
    247                     temp.startime=Processes[i].startime;
    248                     temp.finitime=Processes[i].finitime;
    249                     temp.TAtime=Processes[i].TAtime;
    250                     temp.TAWtime=Processes[i].TAWtime;
    251                     temp.prio=Processes[i].prio;
    252                     temp.id=Processes[i].id;
    253                     temp.HRRF=Processes[i].HRRF;
    254                     temp.dotime=Processes[i].dotime;
    255 
    256                     strcpy(Processes[i].name,Processes[j].name);
    257                     Processes[i].status=Processes[j].status;
    258                     Processes[i].arrtime=Processes[j].arrtime;
    259                     Processes[i].reqtime=Processes[j].reqtime;
    260                     Processes[i].startime=Processes[j].startime;
    261                     Processes[i].finitime=Processes[j].finitime;
    262                     Processes[i].TAtime=Processes[j].TAtime;
    263                     Processes[i].TAWtime=Processes[j].TAWtime;
    264                     Processes[i].prio=Processes[j].prio;
    265                     Processes[i].id=Processes[j].id;
    266                     Processes[i].HRRF=Processes[j].HRRF;
    267                     Processes[i].dotime=Processes[j].dotime;
    268 
    269                     strcpy(Processes[j].name,temp.name);
    270                     Processes[j].status=temp.status;
    271                     Processes[j].arrtime=temp.arrtime;
    272                     Processes[j].reqtime=temp.reqtime;
    273                     Processes[j].startime=temp.startime;
    274                     Processes[j].finitime=temp.finitime;
    275                     Processes[j].TAtime=temp.TAtime;
    276                     Processes[j].TAWtime=temp.TAWtime;
    277                     Processes[j].prio=temp.prio;
    278                     Processes[j].id=temp.id;
    279                     Processes[j].HRRF=temp.HRRF;
    280                     Processes[j].dotime=temp.dotime;
    281                 }
    282             }
    283             else 
    284                 printf("Error!
    ");
    285         }
    286     }
    287 }
    288 void ins()    //插入
    289 {
    290     int i;
    291     while(T!='E'&&T!='e')
    292     {
    293             printf("'I'nsert or 'D'elete or 'E'xit?
    ");
    294             getchar();
    295             scanf("%c",&T);
    296             if(T=='I'||T=='i')
    297             {
    298                 printf("你想插入多少个作业?
    ");
    299                 scanf("%d",&add);
    300                 bfsum=sumProcess;
    301                 sumProcess=sumProcess+add;
    302                 for(i=bfsum+1;i<=sumProcess;i++)
    303                 {
    304                     printf("
    第%d个作业:
    ",i);
    305                     getchar();
    306                     printf("输入作业名:
    ");
    307                     gets(Processes[i].name);
    308                     printf("到达时间:
    ");
    309                     scanf("%d",&Processes[i].arrtime);
    310                     printf("要求服务时间:
    ");
    311                     scanf("%d",&Processes[i].reqtime);
    312                 }
    313             }
    314             else if(T=='D'||T=='d')
    315             {
    316                 printf("你想删除第几组?");
    317                 scanf("%d",&del);
    318                 for(i=del;i<=sumProcess-1;i++)
    319                 {
    320                     strcpy(Processes[i].name,Processes[i+1].name);
    321                     Processes[i].arrtime=Processes[i+1].arrtime;
    322                     Processes[i].reqtime=Processes[i+1].reqtime;
    323                 }
    324                 sumProcess--;
    325             }
    326     }
    327 }
    328 
    329 
    330 void printarr()    //打印
    331 {
    332     int i;
    333     printf("		name	artime	rqtime
    ");
    334     for(i=1;i<=sumProcess;i++)
    335     {
    336         printf("N  %d	",i);
    337         printf("	%s",Processes[i].name);
    338         printf("	%d",Processes[i].arrtime);
    339         printf("	%d
    ",Processes[i].reqtime);
    340     }
    341     printf("						现在系统时间%d
    ",systime);
    342     
    343 }
    344 void printz()
    345 {
    346     int i;
    347     float sum1=0,sum2=0;    //计算平均周转时间、平均带权周转时间
    348     printf("		name	artime	rqtime	stime	ftime	TAtime		TAWtime
    ");
    349     for(i=1;i<=sumProcess;i++)
    350     {
    351         printf("N  %d	",i);
    352         printf("	%s",Processes[i].name);
    353         printf("	%d",Processes[i].arrtime);
    354         printf("	%d",Processes[i].reqtime);
    355         printf("	%d",Processes[i].startime);
    356         printf("	%d",Processes[i].finitime);
    357         printf("	%f",Processes[i].TAtime);
    358         printf("	%f
    ",Processes[i].TAWtime);
    359     }
    360     for(i=1;i<=sumProcess;i++)
    361     {
    362         sum1=sum1+Processes[i].TAtime;
    363     }
    364     for(i=1;i<=sumProcess;i++)
    365     {
    366         sum2=sum2+Processes[i].TAWtime;
    367     }
    368     printf("
    平均周转时间=%f
    ",sum1/sumProcess);
    369     printf("
    平均带权周转时间=%f
    ",sum2/sumProcess);
    370     printf("						现在系统时间%d
    ",systime);
    371 }
    372 void sumofthey()
    373 {
    374     int i;
    375     Processes[1].startime=Processes[1].arrtime;
    376     Processes[1].finitime=Processes[1].arrtime+Processes[1].reqtime;
    377     Processes[1].TAtime=(float)(Processes[1].finitime-Processes[1].arrtime);
    378     Processes[1].TAWtime=(float)(Processes[1].TAtime/Processes[1].reqtime);
    379     Processes[1].HRRF=(float)(Processes[1].TAtime/Processes[1].reqtime);
    380     for(i=2;i<=sumProcess;i++)
    381     {
    382         Processes[i].startime=Processes[i-1].finitime;
    383         Processes[i].finitime=Processes[i].startime+Processes[i].reqtime;
    384         Processes[i].TAtime=(float)(Processes[i].finitime-Processes[i].arrtime);
    385         Processes[i].TAWtime=(float)(Processes[i].TAtime/Processes[i].reqtime);
    386         Processes[i].HRRF=(float)(Processes[i].TAtime/Processes[i].reqtime);
    387     }
    388 }
    389 void startit()
    390 {
    391     int n;
    392     printf("
    ");
    393     printf("			**************************
    ");
    394     printf("			**1.调用文本写入数据******
    ");
    395     printf("			**2.调用伪随机数产生数据**
    ");
    396     printf("			**3.调用自己输入模拟数据**
    ");
    397     printf("			**************************
    ");
    398     scanf("%d",&n);
    399     switch(n)
    400     {
    401     case 1:
    402         readfiles();
    403         sumofthey();
    404         break;
    405     case 2:
    406         ran();
    407         sumofthey();
    408         break;
    409     case 3:
    410         shuru();
    411         sumofthey();
    412         break;
    413     default:
    414         {
    415         printf("输入有误,请重新输入");
    416         break;
    417         }
    418     }
    419 }
    420 void ran()
    421 {
    422     int i;
    423     srand((unsigned)time(0));  //参数seed是rand()的种子,用来初始化rand()的起始值。
    424     sumProcess=rand()%3+5;
    425     for(i=1;i<=sumProcess;i++)
    426     {
    427         itoa(i,Processes[i].name,2);
    428      
    429         Processes[i].arrtime=rand()%29+1;
    430     
    431         Processes[i].reqtime=rand()%7+1;
    432 
    433         Processes[i].prio=rand()%10+1;
    434     }
    435     printf("
     	id    	作业到达时间     	作业运行所需要时间     	优先级
    ");
    436     for(i=1; i<=sumProcess; i++)
    437     {
    438         printf("
    	%s	%12d	%15d	%25f",Processes[i].name,Processes[i].arrtime,Processes[i].reqtime,Processes[i].prio);
    439     }
    440    printf("
    ");
    441 }
    442 
    443 void readfiles()
    444 {
    445     char szTest[1000] = {0};int i=0,n;
    446     FILE *fp=fopen("D:\File1.txt","r");
    447     //FILE *fout=fopen("D:\File2.txt","w");
    448     if(fp == NULL)
    449     {
    450         printf("ERROR!
    ");
    451         exit(0);
    452     }
    453     //fscanf(fp,"Processesum=%d
    ",%n);
    454     while(!feof(fp))  
    455     {
    456         fscanf(fp,"%d%d%d",&Processes[i].id,&Processes[i].arrtime,&Processes[i].reqtime);  //fscanf()函数将数据读入
    457         printf("
    %3d%12d%15d
    ",Processes[i].id,Processes[i].arrtime,Processes[i].reqtime);  //输出到屏幕
    458         itoa(Processes[i].id,Processes[i].name,10);
    459         i++;
    460         /*memset(szTest, 0, sizeof(szTest));
    461         fscanf(fp,"@id=%d|",&i);
    462         fgets(fp,"name=%s|",Processes[i].name);
    463         fscanf(fp,"arrtime=%d|reqtime=%d
    ",&Processes[i].arrtime,&Processes[i].reqtime);
    464         */
    465     //fscanf(fp,"%d",)
    466     }
    467     sumProcess=i;
    468     fclose(fp);
    469 }
    470 void shuru()
    471 {
    472     int i;
    473     printf("作业个数:
    ");
    474     scanf("%d",&sumProcess);
    475     for(i=1;i<=sumProcess;i++)
    476     {
    477         printf("
    第%d个作业:
    ",i);
    478         getchar();
    479         printf("输入作业名:
    ");
    480         gets(Processes[i].name);
    481         printf("到达时间:
    ");
    482         scanf("%d",&Processes[i].arrtime);
    483         printf("要求服务时间:
    ");
    484         scanf("%d",&Processes[i].reqtime);
    485     }
    486     sumofthey();
    487 }
    488 void choosesort()
    489 {
    490     int n;
    491     printf("			*****************************
    ");
    492     printf("			*******1.FCFS算法调度********
    ");
    493     printf("			*******2.SJF算法调度*********
    ");
    494     printf("			*******3.HRRF算法调度********
    ");
    495     printf("			*******4.调用系统清屏********
    ");
    496     printf("			*******5.退出算法调度********
    ");
    497     printf("			*****************************
    ");
    498     scanf("%d",&n);
    499     switch(n)
    500     {
    501     case 1:
    502         printf("运行先来先服务算法FCFS
    ");
    503         sort(1);
    504         printf("
    经按到达时间排序后,未达到队列是
    ");
    505         printz();
    506         break;
    507     case 2:
    508         printf("运行最短作业优先算法FJS
    ");
    509         sort(2);
    510         printf("
    经按到达时间排序后,未达到队列是
    ");
    511         printz();
    512         break;
    513     case 3:
    514         printf("运行最高响应比优先算法HRRF
    ");
    515         sort(3);
    516         printf("
    经按到达时间排序后,未达到队列是
    ");
    517         printz();
    518         break;
    519     case 4:
    520         system("cls");
    521         break;
    522     case 5:
    523         exit(0);
    524         break;
    525     }
    526 }
    527 void main()
    528 {
    529     startit();
    530 //    choosesort();
    531     while(sumProcess!=0)
    532     {
    533         RunProcess();
    534     }
    535 
    536 }
      1 #include<stdio.h>
      2 #include<string.h>
      3 void shuru();
      4 void readfiles();
      5 void ran();
      6 void sort(int choose);//1为到达时间排序,2为服务时间排序,3为HRRF排序,4为优先级排序
      7 void FinishProcess();
      8 typedef struct Process
      9 {
     10     char name[10];
     11     char status;    //状态:开始s,等待d,就绪j
     12     int id;
     13     int arrtime;    //到达时间
     14     int reqtime;    //要求服务时间
     15     int startime;    //开始时间
     16     int finitime;    //完成时间
     17     int dotime;        //已经工作时间
     18 
     19     float TAtime,TAWtime;    //周转时间、带权周转时间
     20     float prio;        //优先级
     21     float HRRF;            //响应比
     22 
     23 }Process;
     24 
     25 
     26 Process Processes[100]; //最多100个作业
     27 int systime=0,bfsum,add,del;
     28 int intarr,infin,intjob,sumProcess;
     29 char T='A';              //T的默认值是A
     30 
     31 void RunProcess()
     32 {
     33     int timeflag=0;
     34     int timepiece=2;
     35     int T;
     36     int k;
     37     char ch;
     38     int i=1;
     39 
     40     printf("
    请输入时间片:");
     41     scanf("%d",&T);
     42 
     43     sort(1);//按FCFS排序
     44     printf("
    ————开始运行————
    ");
     45     while(sumProcess>=0)
     46     {
     47         if(timeflag==T)
     48         {
     49             timeflag=0;
     50             if(Processes[0].reqtime==0)
     51             {
     52             printf("————进程%s已完成————
    ",Processes[0].name);
     53             
     54 
     55             if(sumProcess!=0){
     56                 sort(1);
     57                 printf("当前正在运行进程是:%s————
    ",Processes[0].name);
     58             }
     59             if(sumProcess>=1)
     60                 for(k=1;k<sumProcess;k++)
     61                 printf("————进程%s正在等待————
    ",Processes[k].name);
     62             if(sumProcess==0){
     63                 Processes[0].reqtime--;
     64                 sumProcess--;
     65             }
     66             }
     67             else{
     68                 sort(1);
     69                 if(sumProcess!=0){
     70                 //sort();
     71                 printf("当前正在运行进程是:%s————
    ",Processes[0].name);
     72                 }
     73                 if(sumProcess>=1)
     74                 for(k=1;k<sumProcess;k++)
     75                 printf("————进程%s正在等待————
    ",Processes[k].name);
     76             }              
     77         }
     78         else{
     79             if(Processes[0].reqtime==0)
     80             {
     81             printf("————进程%s已完成————
    ",Processes[0].name);
     82             if(sumProcess!=0){
     83                 sort(1);
     84                 printf("————进程%s正在运行————
    ",Processes[0].name);
     85             }
     86             if(sumProcess>=1)
     87                 for(k=1;k<sumProcess;k++)
     88                 printf("————进程%s正在等待————
    ",Processes[k].name);
     89             }
     90             else{
     91                 Processes[0].reqtime--;
     92                 if(sumProcess!=0)
     93                 printf("————进程%s正在运行————
    ",Processes[0].name);
     94             
     95                 if(sumProcess>=1)
     96                 for(k=1;k<sumProcess;k++)
     97                 printf("————进程%s正在等待————
    ",Processes[k].name);
     98             }
     99         }
    100         timeflag++;
    101         printf("
     按任回车继续......"); 
    102         ch=getchar(); 
    103         ch=getchar();
    104     }
    105      printf("
    
     全部进程已经完成.
    "); 
    106 /*
    107     for(i=1;i<=sumProcess;i++)
    108     {
    109         printf("
    	Process %s	%f
    ",Processes[i].name,Processes[i].prio);
    110     }
    111     Processes[1].dotime++;
    112     if(Processes[1].dotime==Processes[1].reqtime)
    113     {
    114         FinishProcess();
    115     }
    116     Processes[1].prio--;*/
    117 }
    118 
    119 void FinishProcess()
    120 {
    121     int i,j;
    122     Process temp;
    123     for(i=1;i<=sumProcess;i++)
    124     {
    125         j=i-1;
    126                     strcpy(temp.name,Processes[i].name);
    127                     temp.status=Processes[i].status;
    128                     temp.arrtime=Processes[i].arrtime;
    129                     temp.reqtime=Processes[i].reqtime;
    130                     temp.startime=Processes[i].startime;
    131                     temp.finitime=Processes[i].finitime;
    132                     temp.TAtime=Processes[i].TAtime;
    133                     temp.TAWtime=Processes[i].TAWtime;
    134                     temp.prio=Processes[i].prio;
    135                     temp.id=Processes[i].id;
    136                     temp.HRRF=Processes[i].HRRF;
    137                     temp.dotime=Processes[i].dotime;
    138 
    139                     strcpy(Processes[i].name,Processes[j].name);
    140                     Processes[i].status=Processes[j].status;
    141                     Processes[i].arrtime=Processes[j].arrtime;
    142                     Processes[i].reqtime=Processes[j].reqtime;
    143                     Processes[i].startime=Processes[j].startime;
    144                     Processes[i].finitime=Processes[j].finitime;
    145                     Processes[i].TAtime=Processes[j].TAtime;
    146                     Processes[i].TAWtime=Processes[j].TAWtime;
    147                     Processes[i].prio=Processes[j].prio;
    148                     Processes[i].id=Processes[j].id;
    149                     Processes[i].HRRF=Processes[j].HRRF;
    150                     Processes[i].dotime=Processes[j].dotime;
    151 
    152                     strcpy(Processes[j].name,temp.name);
    153                     Processes[j].status=temp.status;
    154                     Processes[j].arrtime=temp.arrtime;
    155                     Processes[j].reqtime=temp.reqtime;
    156                     Processes[j].startime=temp.startime;
    157                     Processes[j].finitime=temp.finitime;
    158                     Processes[j].TAtime=temp.TAtime;
    159                     Processes[j].TAWtime=temp.TAWtime;
    160                     Processes[j].prio=temp.prio;
    161                     Processes[j].id=temp.id;
    162                     Processes[j].HRRF=temp.HRRF;
    163                     Processes[j].dotime=temp.dotime;
    164     }
    165     sumProcess--;
    166 }
    167 
    168 
    169 
    170 void sort(int choose)  //排序
    171 {
    172     int i,j;
    173     Process temp;
    174     for(i=1;i<=sumProcess;i++)
    175     {
    176         for(j=i+1;j<=sumProcess;j++)
    177         {
    178             if(choose==1)
    179             {
    180                 if(Processes[i].arrtime>Processes[j].arrtime)
    181                 {
    182                     strcpy(temp.name,Processes[i].name);
    183                     temp.status=Processes[i].status;
    184                     temp.arrtime=Processes[i].arrtime;
    185                     temp.reqtime=Processes[i].reqtime;
    186                     temp.startime=Processes[i].startime;
    187                     temp.finitime=Processes[i].finitime;
    188                     temp.TAtime=Processes[i].TAtime;
    189                     temp.TAWtime=Processes[i].TAWtime;
    190                     temp.prio=Processes[i].prio;
    191                     temp.id=Processes[i].id;
    192                     temp.HRRF=Processes[i].HRRF;
    193                     temp.dotime=Processes[i].dotime;
    194 
    195                     strcpy(Processes[i].name,Processes[j].name);
    196                     Processes[i].status=Processes[j].status;
    197                     Processes[i].arrtime=Processes[j].arrtime;
    198                     Processes[i].reqtime=Processes[j].reqtime;
    199                     Processes[i].startime=Processes[j].startime;
    200                     Processes[i].finitime=Processes[j].finitime;
    201                     Processes[i].TAtime=Processes[j].TAtime;
    202                     Processes[i].TAWtime=Processes[j].TAWtime;
    203                     Processes[i].prio=Processes[j].prio;
    204                     Processes[i].id=Processes[j].id;
    205                     Processes[i].HRRF=Processes[j].HRRF;
    206                     Processes[i].dotime=Processes[j].dotime;
    207 
    208                     strcpy(Processes[j].name,temp.name);
    209                     Processes[j].status=temp.status;
    210                     Processes[j].arrtime=temp.arrtime;
    211                     Processes[j].reqtime=temp.reqtime;
    212                     Processes[j].startime=temp.startime;
    213                     Processes[j].finitime=temp.finitime;
    214                     Processes[j].TAtime=temp.TAtime;
    215                     Processes[j].TAWtime=temp.TAWtime;
    216                     Processes[j].prio=temp.prio;
    217                     Processes[j].id=temp.id;
    218                     Processes[j].HRRF=temp.HRRF;
    219                     Processes[j].dotime=temp.dotime;
    220                 }
    221             }
    222             else if(choose==2)
    223             {
    224                 if(Processes[i].reqtime>Processes[j].reqtime)
    225                 {
    226                     strcpy(temp.name,Processes[i].name);
    227                     temp.status=Processes[i].status;
    228                     temp.arrtime=Processes[i].arrtime;
    229                     temp.reqtime=Processes[i].reqtime;
    230                     temp.startime=Processes[i].startime;
    231                     temp.finitime=Processes[i].finitime;
    232                     temp.TAtime=Processes[i].TAtime;
    233                     temp.TAWtime=Processes[i].TAWtime;
    234                     temp.prio=Processes[i].prio;
    235                     temp.id=Processes[i].id;
    236                     temp.HRRF=Processes[i].HRRF;
    237                     temp.dotime=Processes[i].dotime;
    238 
    239                     strcpy(Processes[i].name,Processes[j].name);
    240                     Processes[i].status=Processes[j].status;
    241                     Processes[i].arrtime=Processes[j].arrtime;
    242                     Processes[i].reqtime=Processes[j].reqtime;
    243                     Processes[i].startime=Processes[j].startime;
    244                     Processes[i].finitime=Processes[j].finitime;
    245                     Processes[i].TAtime=Processes[j].TAtime;
    246                     Processes[i].TAWtime=Processes[j].TAWtime;
    247                     Processes[i].prio=Processes[j].prio;
    248                     Processes[i].id=Processes[j].id;
    249                     Processes[i].HRRF=Processes[j].HRRF;
    250                     Processes[i].dotime=Processes[j].dotime;
    251 
    252                     strcpy(Processes[j].name,temp.name);
    253                     Processes[j].status=temp.status;
    254                     Processes[j].arrtime=temp.arrtime;
    255                     Processes[j].reqtime=temp.reqtime;
    256                     Processes[j].startime=temp.startime;
    257                     Processes[j].finitime=temp.finitime;
    258                     Processes[j].TAtime=temp.TAtime;
    259                     Processes[j].TAWtime=temp.TAWtime;
    260                     Processes[j].prio=temp.prio;
    261                     Processes[j].id=temp.id;
    262                     Processes[j].HRRF=temp.HRRF;
    263                     Processes[j].dotime=temp.dotime;
    264                 }
    265             }
    266             else if(choose==3)
    267             {
    268                 if(Processes[i].HRRF<Processes[j].HRRF)
    269                 {
    270                     strcpy(temp.name,Processes[i].name);
    271                     temp.status=Processes[i].status;
    272                     temp.arrtime=Processes[i].arrtime;
    273                     temp.reqtime=Processes[i].reqtime;
    274                     temp.startime=Processes[i].startime;
    275                     temp.finitime=Processes[i].finitime;
    276                     temp.TAtime=Processes[i].TAtime;
    277                     temp.TAWtime=Processes[i].TAWtime;
    278                     temp.prio=Processes[i].prio;
    279                     temp.id=Processes[i].id;
    280                     temp.HRRF=Processes[i].HRRF;
    281                     temp.dotime=Processes[i].dotime;
    282 
    283                     strcpy(Processes[i].name,Processes[j].name);
    284                     Processes[i].status=Processes[j].status;
    285                     Processes[i].arrtime=Processes[j].arrtime;
    286                     Processes[i].reqtime=Processes[j].reqtime;
    287                     Processes[i].startime=Processes[j].startime;
    288                     Processes[i].finitime=Processes[j].finitime;
    289                     Processes[i].TAtime=Processes[j].TAtime;
    290                     Processes[i].TAWtime=Processes[j].TAWtime;
    291                     Processes[i].prio=Processes[j].prio;
    292                     Processes[i].id=Processes[j].id;
    293                     Processes[i].HRRF=Processes[j].HRRF;
    294                     Processes[i].dotime=Processes[j].dotime;
    295 
    296                     strcpy(Processes[j].name,temp.name);
    297                     Processes[j].status=temp.status;
    298                     Processes[j].arrtime=temp.arrtime;
    299                     Processes[j].reqtime=temp.reqtime;
    300                     Processes[j].startime=temp.startime;
    301                     Processes[j].finitime=temp.finitime;
    302                     Processes[j].TAtime=temp.TAtime;
    303                     Processes[j].TAWtime=temp.TAWtime;
    304                     Processes[j].prio=temp.prio;
    305                     Processes[j].id=temp.id;
    306                     Processes[j].HRRF=temp.HRRF;
    307                     Processes[j].dotime=temp.dotime;
    308                 }
    309             }
    310             else if(choose==4)
    311             {
    312                 if(Processes[i].prio<Processes[j].prio)
    313                 {
    314                     strcpy(temp.name,Processes[i].name);
    315                     temp.status=Processes[i].status;
    316                     temp.arrtime=Processes[i].arrtime;
    317                     temp.reqtime=Processes[i].reqtime;
    318                     temp.startime=Processes[i].startime;
    319                     temp.finitime=Processes[i].finitime;
    320                     temp.TAtime=Processes[i].TAtime;
    321                     temp.TAWtime=Processes[i].TAWtime;
    322                     temp.prio=Processes[i].prio;
    323                     temp.id=Processes[i].id;
    324                     temp.HRRF=Processes[i].HRRF;
    325                     temp.dotime=Processes[i].dotime;
    326 
    327                     strcpy(Processes[i].name,Processes[j].name);
    328                     Processes[i].status=Processes[j].status;
    329                     Processes[i].arrtime=Processes[j].arrtime;
    330                     Processes[i].reqtime=Processes[j].reqtime;
    331                     Processes[i].startime=Processes[j].startime;
    332                     Processes[i].finitime=Processes[j].finitime;
    333                     Processes[i].TAtime=Processes[j].TAtime;
    334                     Processes[i].TAWtime=Processes[j].TAWtime;
    335                     Processes[i].prio=Processes[j].prio;
    336                     Processes[i].id=Processes[j].id;
    337                     Processes[i].HRRF=Processes[j].HRRF;
    338                     Processes[i].dotime=Processes[j].dotime;
    339 
    340                     strcpy(Processes[j].name,temp.name);
    341                     Processes[j].status=temp.status;
    342                     Processes[j].arrtime=temp.arrtime;
    343                     Processes[j].reqtime=temp.reqtime;
    344                     Processes[j].startime=temp.startime;
    345                     Processes[j].finitime=temp.finitime;
    346                     Processes[j].TAtime=temp.TAtime;
    347                     Processes[j].TAWtime=temp.TAWtime;
    348                     Processes[j].prio=temp.prio;
    349                     Processes[j].id=temp.id;
    350                     Processes[j].HRRF=temp.HRRF;
    351                     Processes[j].dotime=temp.dotime;
    352                 }
    353             }
    354             else 
    355                 printf("Error!
    ");
    356         }
    357     }
    358 }
    359 void ins()    //插入
    360 {
    361     int i;
    362     while(T!='E'&&T!='e')
    363     {
    364             printf("'I'nsert or 'D'elete or 'E'xit?
    ");
    365             getchar();
    366             scanf("%c",&T);
    367             if(T=='I'||T=='i')
    368             {
    369                 printf("你想插入多少个作业?
    ");
    370                 scanf("%d",&add);
    371                 bfsum=sumProcess;
    372                 sumProcess=sumProcess+add;
    373                 for(i=bfsum+1;i<=sumProcess;i++)
    374                 {
    375                     printf("
    第%d个作业:
    ",i);
    376                     getchar();
    377                     printf("输入作业名:
    ");
    378                     gets(Processes[i].name);
    379                     printf("到达时间:
    ");
    380                     scanf("%d",&Processes[i].arrtime);
    381                     printf("要求服务时间:
    ");
    382                     scanf("%d",&Processes[i].reqtime);
    383                 }
    384             }
    385             else if(T=='D'||T=='d')
    386             {
    387                 printf("你想删除第几组?");
    388                 scanf("%d",&del);
    389                 for(i=del;i<=sumProcess-1;i++)
    390                 {
    391                     strcpy(Processes[i].name,Processes[i+1].name);
    392                     Processes[i].arrtime=Processes[i+1].arrtime;
    393                     Processes[i].reqtime=Processes[i+1].reqtime;
    394                 }
    395                 sumProcess--;
    396             }
    397     }
    398 }
    399 
    400 
    401 void printarr()    //打印
    402 {
    403     int i;
    404     printf("		name	artime	rqtime
    ");
    405     for(i=1;i<=sumProcess;i++)
    406     {
    407         printf("N  %d	",i);
    408         printf("	%s",Processes[i].name);
    409         printf("	%d",Processes[i].arrtime);
    410         printf("	%d
    ",Processes[i].reqtime);
    411     }
    412     printf("						现在系统时间%d
    ",systime);
    413     
    414 }
    415 void printz()
    416 {
    417     int i;
    418     float sum1=0,sum2=0;    //计算平均周转时间、平均带权周转时间
    419     printf("		name	artime	rqtime	stime	ftime	TAtime		TAWtime
    ");
    420     for(i=1;i<=sumProcess;i++)
    421     {
    422         printf("N  %d	",i);
    423         printf("	%s",Processes[i].name);
    424         printf("	%d",Processes[i].arrtime);
    425         printf("	%d",Processes[i].reqtime);
    426         printf("	%d",Processes[i].startime);
    427         printf("	%d",Processes[i].finitime);
    428         printf("	%f",Processes[i].TAtime);
    429         printf("	%f
    ",Processes[i].TAWtime);
    430     }
    431     for(i=1;i<=sumProcess;i++)
    432     {
    433         sum1=sum1+Processes[i].TAtime;
    434     }
    435     for(i=1;i<=sumProcess;i++)
    436     {
    437         sum2=sum2+Processes[i].TAWtime;
    438     }
    439     printf("
    平均周转时间=%f
    ",sum1/sumProcess);
    440     printf("
    平均带权周转时间=%f
    ",sum2/sumProcess);
    441     printf("						现在系统时间%d
    ",systime);
    442 }
    443 void sumofthey()
    444 {
    445     int i;
    446     Processes[1].startime=Processes[1].arrtime;
    447     Processes[1].finitime=Processes[1].arrtime+Processes[1].reqtime;
    448     Processes[1].TAtime=(float)(Processes[1].finitime-Processes[1].arrtime);
    449     Processes[1].TAWtime=(float)(Processes[1].TAtime/Processes[1].reqtime);
    450     Processes[1].HRRF=(float)(Processes[1].TAtime/Processes[1].reqtime);
    451     for(i=2;i<=sumProcess;i++)
    452     {
    453         Processes[i].startime=Processes[i-1].finitime;
    454         Processes[i].finitime=Processes[i].startime+Processes[i].reqtime;
    455         Processes[i].TAtime=(float)(Processes[i].finitime-Processes[i].arrtime);
    456         Processes[i].TAWtime=(float)(Processes[i].TAtime/Processes[i].reqtime);
    457         Processes[i].HRRF=(float)(Processes[i].TAtime/Processes[i].reqtime);
    458     }
    459 }
    460 void startit()
    461 {
    462     int n;
    463     printf("
    ");
    464     printf("			**************************
    ");
    465     printf("			**1.调用文本写入数据******
    ");
    466     printf("			**2.调用伪随机数产生数据**
    ");
    467     printf("			**3.调用自己输入模拟数据**
    ");
    468     printf("			**************************
    ");
    469     scanf("%d",&n);
    470     switch(n)
    471     {
    472     case 1:
    473         readfiles();
    474         sumofthey();
    475         break;
    476     case 2:
    477         ran();
    478         sumofthey();
    479         break;
    480     case 3:
    481         shuru();
    482         sumofthey();
    483         break;
    484     default:
    485         {
    486         printf("输入有误,请重新输入");
    487         break;
    488         }
    489     }
    490 }
    491 void ran()
    492 {
    493     int i;
    494     srand((unsigned)time(0));  //参数seed是rand()的种子,用来初始化rand()的起始值。
    495     sumProcess=rand()%3+5;
    496     for(i=1;i<=sumProcess;i++)
    497     {
    498         itoa(i,Processes[i].name,2);
    499      
    500         Processes[i].arrtime=rand()%29+1;
    501     
    502         Processes[i].reqtime=rand()%7+1;
    503 
    504         Processes[i].prio=rand()%10+1;
    505     }
    506     printf("
     	id    	作业到达时间     	作业运行所需要时间     	优先级
    ");
    507     for(i=1; i<=sumProcess; i++)
    508     {
    509         printf("
    	%s	%12d	%15d	%25f",Processes[i].name,Processes[i].arrtime,Processes[i].reqtime,Processes[i].prio);
    510     }
    511    printf("
    ");
    512 }
    513 
    514 void readfiles()
    515 {
    516     char szTest[1000] = {0};int i=0,n;
    517     FILE *fp=fopen("D:\File1.txt","r");
    518     //FILE *fout=fopen("D:\File2.txt","w");
    519     if(fp == NULL)
    520     {
    521         printf("ERROR!
    ");
    522         exit(0);
    523     }
    524     //fscanf(fp,"Processesum=%d
    ",%n);
    525     while(!feof(fp))  
    526     {
    527         fscanf(fp,"%d%d%d",&Processes[i].id,&Processes[i].arrtime,&Processes[i].reqtime);  //fscanf()函数将数据读入
    528         printf("
    %3d%12d%15d
    ",Processes[i].id,Processes[i].arrtime,Processes[i].reqtime);  //输出到屏幕
    529         itoa(Processes[i].id,Processes[i].name,10);
    530         i++;
    531         /*memset(szTest, 0, sizeof(szTest));
    532         fscanf(fp,"@id=%d|",&i);
    533         fgets(fp,"name=%s|",Processes[i].name);
    534         fscanf(fp,"arrtime=%d|reqtime=%d
    ",&Processes[i].arrtime,&Processes[i].reqtime);
    535         */
    536     //fscanf(fp,"%d",)
    537     }
    538     sumProcess=i;
    539     fclose(fp);
    540 }
    541 void shuru()
    542 {
    543     int i;
    544     printf("作业个数:
    ");
    545     scanf("%d",&sumProcess);
    546     for(i=1;i<=sumProcess;i++)
    547     {
    548         printf("
    第%d个作业:
    ",i);
    549         getchar();
    550         printf("输入作业名:
    ");
    551         gets(Processes[i].name);
    552         printf("到达时间:
    ");
    553         scanf("%d",&Processes[i].arrtime);
    554         printf("要求服务时间:
    ");
    555         scanf("%d",&Processes[i].reqtime);
    556     }
    557     sumofthey();
    558 }
    559 void choosesort()
    560 {
    561     int n;
    562     printf("			*****************************
    ");
    563     printf("			*******1.FCFS算法调度********
    ");
    564     printf("			*******2.SJF算法调度*********
    ");
    565     printf("			*******3.HRRF算法调度********
    ");
    566     printf("			*******4.调用系统清屏********
    ");
    567     printf("			*******5.退出算法调度********
    ");
    568     printf("			*****************************
    ");
    569     scanf("%d",&n);
    570     switch(n)
    571     {
    572     case 1:
    573         printf("运行先来先服务算法FCFS
    ");
    574         sort(1);
    575         printf("
    经按到达时间排序后,未达到队列是
    ");
    576         printz();
    577         break;
    578     case 2:
    579         printf("运行最短作业优先算法FJS
    ");
    580         sort(2);
    581         printf("
    经按到达时间排序后,未达到队列是
    ");
    582         printz();
    583         break;
    584     case 3:
    585         printf("运行最高响应比优先算法HRRF
    ");
    586         sort(3);
    587         printf("
    经按到达时间排序后,未达到队列是
    ");
    588         printz();
    589         break;
    590     case 4:
    591         system("cls");
    592         break;
    593     case 5:
    594         exit(0);
    595         break;
    596     }
    597 }
    598 void main()
    599 {
    600     startit();
    601 //    choosesort();
    602     while(sumProcess!=0)
    603     {
    604         RunProcess();
    605     }
    606 
    607 }
  • 相关阅读:
    Codeforces-754D Fedor and coupons
    LightOJ
    LightOJ
    LightOJ
    LightOJ
    POJ
    HDU
    HDU
    HDU-2159
    方法的重写
  • 原文地址:https://www.cnblogs.com/mxdmxdmxd78/p/5446543.html
Copyright © 2011-2022 走看看