头歌实验5：处理机调度（编程实验）

第一关

任务
本关任务：编写一个先来先服务器调度算法解决一个实际的进程调度问题，并打印出每个进程的完成时间、周转时间和带权周转时间。
给定一组进程的到达时间和服务时间，实现先来先服务调度算法，并打印出调度结果，包括每个进程的完成时间、周转时间和带权周转时间。

       进程         到达时间    服务时间
          A           0            3
          B           2            6
          C           4            4
          D           6            5
          E           8            2

服务调度算法FCFS
FCFS是最简单的调度算法，该算法既可用于作业调度，也可用于进程调度。当在作业调度中采用该算法时，系统将按照作业到达的先后次序来进行调度，或者说它是优先考虑在系统中等待时间最长的作业
周转时间和带权周转时间
周转时间=完成时间-到达时间
带权周转时间=周转时间/执行时间
题目数据的数据结构

typedef struct JCB
{
	char name[10];
	int arriveTime;  //到达时间 
	int serveTime;   //服务时间 
	int finishTime;  //完成时间 
	int aroundTime;  //周转时间 
	float waroundTime; //带权周转时间 
}PCB;

数据的输入输出

void input(PCB pcb[N])
{
	strcpy(pcb[0].name,"A");
	pcb[0].arriveTime = 0;
	pcb[0].serveTime = 3;
	
	strcpy(pcb[1].name,"B");
	pcb[1].arriveTime = 2;
	pcb[1].serveTime = 6;
	
	strcpy(pcb[2].name,"C");
	pcb[2].arriveTime = 4;
	pcb[2].serveTime = 4;
	
	strcpy(pcb[3].name,"D");
	pcb[3].arriveTime = 6;
	pcb[3].serveTime = 5;
	
	strcpy(pcb[4].name,"E");
	pcb[4].arriveTime = 8;
	pcb[4].serveTime = 2;
	
	int i = 0;
	for(; i < N; ++i)
	{
		pcb[i].finishTime = 0;
		pcb[i].aroundTime = 0;
		pcb[i].waroundTime = 0;
	}

}

void output(PCB pcb[N])
{
	int i = 0;
	printf("进程\t");
	printf("完成时间\t");
	printf("周转时间\t");
	printf("带权周转时间\t\n");
	for(; i < N; ++i)
	{
		printf("%s\t",pcb[i].name);
		printf("%d\t\t",pcb[i].finishTime);
		printf("%d\t\t",pcb[i].aroundTime);
		printf("%f\t\t\n",pcb[i].waroundTime);
	}
}

上答案：

//先来先服务调度算法 
void FCFS(PCB pcb[N])
{
    //由题，题目中的数据刚好就是到达时间递增的顺序排列的
    pcb[0].finishTime=pcb[0].arriveTime+pcb[0].serveTime;
    pcb[0].aroundTime=pcb[0].finishTime-pcb[0].arriveTime;
    pcb[0].waroundTime=((float)pcb[0].aroundTime/(float)pcb[0].serveTime)*1.0;
    for(int i=1;i<5;i++)
    {
        if(pcb[i].arriveTime<pcb[i-1].finishTime)
        {
            pcb[i].finishTime=pcb[i-1].finishTime+pcb[i].serveTime;
            pcb[i].aroundTime=pcb[i].finishTime-pcb[i].arriveTime;
            pcb[i].waroundTime=((float)pcb[i].aroundTime/(float)pcb[i].serveTime)*1.0;
        }else
        {
            pcb[i].finishTime=pcb[i].arriveTime+pcb[i].serveTime;
            pcb[i].aroundTime=pcb[i].finishTime-pcb[i].arriveTime;
            pcb[i].waroundTime=((float)pcb[i].aroundTime/(float)pcb[i].serveTime)*1.0;
        }
    }
	//请补充先来先服务算法的实现代码
}

看看main函数：

int main()
{
	PCB pcb[N];
	
	input(pcb);
	FCFS(pcb);
	printf("先来先服务FCFS:\n"); 
	output(pcb);
	printf("\n");
	
}

第二关

任务
本关任务：编写一个先来先服务器调度算法解决一个实际的进程调度问题，并打印出每个进程的完成时间、周转时间和带权周转时间。也就是按运行时间来
短作业优先调度算法SJF
SJF算法是以作业的长短来计算优先级，作业越短，其优先级越高。作业的长短是以作业所要求的运行时间来衡量的。SJF算法可以分别用于作业调度和进程调度，处理机优先选择运行时间短的作业或者进程。

话不多说，直接上答案

int check(PCB pcb[N],int f,int st[N])
{
    int res;
    int ll=10010;
    for(int i=0;i<5;i++)
    {
        if(st[i]==0)
            if(f>pcb[i].arriveTime && ll>pcb[i].serveTime)
            {
                    ll=pcb[i].serveTime;
                    res=i;//找剩下的里面最小的
            }
    }
    return res;
}//检查函数，返回最小的

//短作业优先调度算法 
void SJF(PCB pcb[N])
{
    int st[N]={0};
    int f;//标记
    pcb[0].finishTime=pcb[0].arriveTime+pcb[0].serveTime;
    pcb[0].aroundTime=pcb[0].finishTime-pcb[0].arriveTime;
    pcb[0].waroundTime=((float)pcb[0].aroundTime/(float)pcb[0].serveTime)*1.0;
    f=pcb[0].finishTime;
    st[0]=1;
    
    
        
    for(int i=1;i<5;i++)
    {
        int res=check(pcb,f,st);
        pcb[res].finishTime=f+pcb[res].serveTime;
        pcb[res].aroundTime=pcb[res].finishTime-pcb[res].arriveTime;
        pcb[res].waroundTime=((float)pcb[res].aroundTime/(float)pcb[res].serveTime)*1.0;
        f=pcb[res].finishTime;
        st[res]=1;
    }
	//请补充短作业优先算法的实现代码
}

第三关

任务
为了完成本关任务，你需要掌握：1.先来先服务调度算法，2.进程周转时间和平均周转时间的计算方法。3、响应比的计算方法
高响应比优先调度算法HRRN
高响应比优先算法引入了响应比的概念，响应比定义如下
响应比=（等待时间+运行时间）/运行时间
高响应比优先算法每次选择响应比最高的进程，进程的响应比是动态变化的，既考虑了进程的等待时间，也考虑了进程的服务时间。

上答案

int check(PCB pcb[N],int f,int st[N])
{
    int res;
    float ll=0;
    for(int i=0;i<5;i++)
    {
        if(st[i]==0)
            if(f>pcb[i].arriveTime )
            {
                float a=(float)(f-pcb[i].arriveTime)/(float)pcb[i].serveTime;
                if(ll<a)
                {
                    res=i;
                    ll=a;
                }
            }
    }
    return res;
}

//高响应比优先调度算法 
void HRRN(PCB pcb[N])
{
    int st[N]={0};
    int f;//标记
    pcb[0].finishTime=pcb[0].arriveTime+pcb[0].serveTime;
    pcb[0].aroundTime=pcb[0].finishTime-pcb[0].arriveTime;
    pcb[0].waroundTime=((float)pcb[0].aroundTime/(float)pcb[0].serveTime)*1.0;
    f=pcb[0].finishTime;
    st[0]=1;
    for(int i=1;i<5;i++)
    {
        int res=check(pcb,f,st);
        
        pcb[res].finishTime=f+pcb[res].serveTime;
        pcb[res].aroundTime=pcb[res].finishTime-pcb[res].arriveTime;
        pcb[res].waroundTime=((float)pcb[res].aroundTime/(float)pcb[res].serveTime)*1.0;
        
        f=pcb[res].finishTime;
        st[res]=1;
    }
    
	//请补充高响应比优先调度算法实现代码
}