处理机调度之高响应比调度算法的实现

高响应比调度算法的实现

学校的一个处理机调度实验，可能有的细节做的不是很好，但能运行出想要的结果，希望能够帮助有需要的人。

#include <stdio.h>
#include <stdlib.h> 
#include<string.h>
//定义一个结构体
struct jcb{
char name[10];   //作业名
float arrivetime;   //到达时间
float servicetime;   //服务时间
float starttime;   //开始时间
float finishtime;   //完成时间
float rtime;    //周转时间
float drtime;   //带权周转
float Rp;       //响应比 
}*b;
 
static int N;    //作业个数 
 
//定义一个结构体数组
jcb a[100];
 
//向文档读入数据的函数
void input(jcb *a) 
{ 
    printf("--------------------------------高响应比调度算法------------------------------\n");
    printf("请输入进程的数量：\n");
    scanf("%d",&N);
	printf("请输入各个进程的名字:\n");
	for(int i=0;i<N;i++)
	{
		scanf("%s",&a[i].name);
	 } 
	 printf("请输入各个进程的到达时间:\n");
	 for(int i=0;i<N;i++)
	 {
	 	scanf("%f",&a[i].arrivetime);
	 }
	 
	 printf("请输入各个进程的运行时间:\n");
	 for(int i=0;i<N;i++)
	 {
	 	scanf("%f",&a[i].servicetime);
	 }
	
printf("****************************************************************\n");
 
}
 
//显示输入的数据 
void display(jcb *a)
{
	printf("输入的数据：\n");
	printf("进程数：%d\n",N);
	printf("进程名  到达时间   服务时间\n");
	for(int i=0;i<N;i++){
	printf("  %s      %2.2f       %2.2f\n",a[i].name,a[i].arrivetime,a[i].servicetime);
   }
}
 
//定义一个输出函数
void Print(jcb *p,int N)
{
	int k;
    printf("\n");
    printf("执行的顺序是:");   //执行顺序
    printf("%s",p[0].name);  //输出第一个完成的进程名 
    for(k=1;k<N;k++)
	{
		printf("-->%s",p[k].name);
	} 
	printf("\n");
   	printf("\n                            -----------结果------------                         ");
	printf("\n================================================================================\n");
	printf("进程名   到达时间  服务时间  开始时间  完成时间   周转时间   带权周转时间\n");
   
    for(k=0;k<=N-1;k++)
	{ 
		printf("%4s  %8.2f  %9.2f  %7.2f  %9.2f  %9.2f %12.2f\n",p[k].name,p[k].arrivetime,p[k].servicetime,p[k].starttime,p[k].finishtime,p[k].rtime,p[k].drtime);
	}
   
}
//按到达时间排序
void sort(jcb *p,int N)
{
	for(int i=0;i<N;i++)
    for(int j=0;j<=i;j++)
    if(p[i].arrivetime<p[j].arrivetime)
	{
		jcb temp;
        temp=p[i];
        p[i]=p[j];
        p[j]=temp;
    }
}
 
//运行阶段
void deal(jcb *p,int N)
{ 
	int k;
    for(k=0;k<N;k++)
	{
         if(k==0)
         { 
             p[k].starttime=p[k].arrivetime;//第一个进程的开始时间=到达时间
             p[k].finishtime=p[k].arrivetime+p[k].servicetime;}//完成时间=到达时间+服务时间
         else  //不是第一个进程 
		 {
			 if(p[k-1].finishtime>=p[k].arrivetime) //如果前一个进程的完成时间大于或者等于当前的进程的到达时间 
			 {
				 p[k].starttime=p[k-1].finishtime;}  //当前的进程开始时间等于前一个进程完成时间 
			 else  
			 {
			 p[k].starttime =p[k].arrivetime;}  //当前进程开始时间等于当前进程的到达时间 
			 p[k].finishtime=p[k].starttime+p[k].servicetime;  
		 }
	}
 
     for(k=0;k<N;k++)
     {
     p[k].rtime=p[k].finishtime-p[k].arrivetime;//周转时间=完成时间-到达时间
     p[k].drtime=p[k].rtime/p[k].servicetime;//带权周转时间=周转时间/服务时间
     
     }
}
 
//高响应比优先调度算法
void hrrn(jcb *p,int N)
{
	display(p);  // 调用函数display() 
    float rtime=0,drtime=0,Rp=0;
    int num=1;
    
    sort(p,N);
    		printf("-------------------------------------------------------------------------------");
    for(int m=0;m<N-1;m++)
    {
    	if(m==0)
		p[m].finishtime=p[m].arrivetime+p[m].servicetime;
		else
		{
			if(p[m-1].finishtime >=p[m].arrivetime )
			{
				p[m].starttime=p[m-1].finishtime;
			}
			else
			{
				p[m].starttime =p[m].arrivetime;
			}
			p[m].finishtime=p[m].starttime+p[m].servicetime;
		}
		 

		int i=0;
		for(int n=m+1;n<N;n++)
		{
			if(p[n].arrivetime<=p[m].finishtime)//按到达时间排序之后，有i个的后面的作业比m完成前到来 
            i++;
		}
		
		 
		 //按高响应比排序
        p[m+1].Rp=(p[m].finishtime-p[m+1].arrivetime+p[m+1].servicetime)/p[m+1].servicetime; //Rp=（上一个(m)完成时间-当前的到达时间 +服务时间）/服务时间 
         //检测代码 
        printf("\n");
        printf("第%d次调度:\n",num++);
        printf("\t进程名  \t到达时间\t服务时间\t\t优先权\n");
        printf("\t%4s    \t%8.2f\t%9.2f\t%12.2f\n",p[m+1].name,p[m+1].arrivetime,p[m+1].servicetime,p[m+1].Rp);
		float max=p[m+1].Rp; 
        int next=m+1;//m+1=n
        for(int k=m+1;k<m+i;k++)
		{
		  p[k+1].Rp=(p[m].finishtime-p[k+1].arrivetime+p[k+1].servicetime)/p[k+1].servicetime;
         //检测代码 
          printf("\t%4s    \t%8.2f\t%9.2f\t%12.2f\n",p[k+1].name,p[k+1].arrivetime,p[k+1].servicetime,p[k+1].Rp);
		
		  if(p[k+1].Rp>max)  //找出响应比最大的进程 
          {
          	max=p[k+1].Rp;
          	next=k+1;
		  }
            
		}
            jcb temp;
            temp=p[m+1];
            p[m+1]=p[next];
            p[next]=temp;
	}
	deal(p,N);
   
    Print(p,N);
} 
 
      
int main()
{ 
   printf("高响应比调度算法 \n");
	    input(a);    
        hrrn(a,N);
		return 0; 
}

运行结果（如下截图）