最短作業優先（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無法通過。