最短作业优先算法（不完善）

最短作业优先（SJF）

问题描述：

最短作业优先（SJF）是一种调试任务请求的调试策略。每个任务请求都含有请求时间（即向系统提交请求的时间）和持续时间（即完成任务所需时间）属性。当前任务完成后，SJF策略选择最短持续时间的任务执行；如果多个任务具有相同持续时间，那么选择请求时间最早的任务。任务的等待时间为实际开始的时间和请求时间的差值。

给定任务的请求时间和持续时间列表，设计一个程序，使用短作业优先算法求平均等待时间。

函数说明

实现方法：

float minWaitingTime(int *requestTimes,int *durations,int n)

输入：requestTimes 表示任务请求时间的整数列表；durations 表示任务持续时间的整数列表；n 表示任务的数量。

输出：返回使用**非抢占式**SJF调度而计算出的所有任务平均等待时间浮点数。

举例：

当requestTimes={0,2,4,5}，durations={7,4,1,4}，n=4时，返回平均等待时间为4.000000。

下面为个人写的实现代码，有某些用例测试无法通过：

float minWaitingTime(int *requestTimes,int *durations,int n)
{   
    /*方法一：自己所写*/
    int ctime=0;        //当前时间
    int *wtime=(int*)malloc(n*sizeof(int));     //每个作业的等待时间
    int *flag=(int*)malloc(n*sizeof(int));      //每个作业是否执行的标志，若执行则置1
    int i=0;            //总循环变量
    int next=0;         //下一个进入处理的作业序号
    int min=500;        //最短的作业运行时间随，开始的时候便取个很大的值
    float totaltime=0;
    for(;i<n;i++)       //初始将每个作业等待时间和其标志都置0
    {
        wtime[i]=0;
        flag[i]=0;
    }
    for(i=0;i<n;i++)
    {
        if(i==0)        //第一次执行的时候，不用考虑作业的运行时间长短，直接把requestTimes[0]==0所对应的那个作业投入运行   &&requestTimes[0]==0
        {
            //if(requestTimes[0]!=0)    ctime+=requestTimes[0];
            flag[i]=1;
            ctime+=durations[i];
            for(int j=0;j<n;j++)                //只有当该作业还没被运行时，才能累加等待时间
            {
                if(flag[j]==0)
                {
                    wtime[j]=ctime-requestTimes[j];
                }
            }
        }
        else                                    //if(requestTimes[0]!=0)
        {
            for(int k=0;k<n;k++)                //找出剩下的作业中，运行时间最短的一个
            {
                if(flag[k]==0)                  //如果其标志为0，则是剩下的没有运行的作业
                {
                    if(durations[k]<min)        //找出运行时间最小的那个
                    {
                        min=durations[k];       
                        next=k;
                    }
                }
            }
            flag[next]=1;                       //将最小运行时间那个作业置1，表示它被运行了
            ctime=ctime+min;                    //此时系统时间加上最小的运行时间
            min=500;                            //又要将min取到非常非常大以进入下一次循环
            for(int m=0;m<n;m++)
            {
                if(flag[m]==0)                  //当该作业还没被运行时，才能累加等待时间
                {
                    wtime[m]=ctime-requestTimes[m];     //用当前的系统时间减去它的开始时间，即得到其等待时间
                }
            }
        }
    }
    for(i=0;i<n;i++)                //计算总等待时间
    {
        totaltime+=wtime[i];
    }

    return totaltime/n;             //返回平均等待时间

/*方法二：参考http://blog.csdn.net/u013749540/article/details/52312910内容
    int *flag=(int*)malloc(n*sizeof(int));      //每个作业是否执行的标志，若执行则置1
    int *ready=(int*)malloc(n*sizeof(int));     //还未运行，并且在当前时间前就已经就绪的作业（即处于等待状态）    
    int ready_n=0;                              //还未运行并且已经处于等待状态的作业数
    int ctime=0;        //当前时间
    float wtime=0;      //已运行作业的总等待时间
    int current=0;      //当前作业的序号
    int next=0;         //下一个进入处理的作业序号
    int min=500;        //最短的作业运行时间，开始的时候便取个很大的值
    int i=0;            //总循环变量
    for(;i<n;i++)       //初始将每个作业等待时间和其标志都置0
    {
        ready[i]=0;
        flag[i]=0;
    }

    for(i=0;i<n;i++)
    {
        //if(i==0&&requestTimes[0]!=0)  ctime=requestTimes[0];

        wtime=wtime+(ctime-requestTimes[current]);      //已运行的总等待时间=上一次wtime+当前系统时间-作业开始时间
        ctime=ctime+durations[current];                 //目前的系统时间=上一次ctime+当前作业运行时间
        flag[current]=1;                                //编号为current的作业运行了就将其标志置1

        ready_n=0;
        for(int j=0;j<n;j++)                            //将还未运行并且已经处于等待状态的作业编号装入ready[]数组
        {
            if(flag[j]==0&&requestTimes[j]<=ctime)
            {
                ready[ready_n++]=j;
            }
        }

        min=500;
        for(int k=0;k<ready_n;k++)                      //从ready[]数组中把运行时间最少的那个作业找出来，并将其编号赋给next
        {
            if(durations[ready[k]]<min)
            {
                min=durations[ready[k]];
                next=ready[k];
            }
        }       
        current=next;                                   //将下一个任务赋给当前任务，进入下一次循环
    }
    return wtime/n;             //返回平均等待时间  
*/
}

void main()
{
    int retime[]={0,2,4,5};//{1,1,1,2};//
    int drtime[]={7,4,1,4};//{4,3,5,1};//
    int n=sizeof(retime)/sizeof(int);
    float wt=minWaitingTime(retime,drtime,n);
    printf("平均等待时间为：%f\n",wt);
}

NOTE：上述两种方法均没考虑到requestTimes[0]！=的情况，用例requestTimes={1,1,1,2}，durations={4,3,5,1}，n=4无法通过。