关闭

最短作业优先算法(不完善)

标签: 算法
245人阅读 评论(0) 收藏 举报
分类:

最短作业优先(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无法通过。

0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:248次
    • 积分:12
    • 等级:
    • 排名:千里之外
    • 原创:1篇
    • 转载:0篇
    • 译文:0篇
    • 评论:0条
    文章分类
    文章存档