先来先服务FCFS和短作业优先算法SJF

代码原本是参考连胜是我偶像作者的代码，

我本来是用来写实验报告答辩的，图省事，但是copy运行下来发现有一些不太完美的地方，其中的void sjf(struct homework homeworks[50],int n)方法并不能正确的计算出短作业优先进程。

所以，对代码做了一些修改，也欢迎各位同学参考借鉴，对代码出错的地方在评论区留下你宝贵的意见。

#include<stdio.h>
#include<string.h>

struct homework{
	char name[10];    // 进程的名字  
	int arrivetime;   // 进程的到达时间
	int servicetime;   // 进程的服务时间
	int starttime;   // 进程的开始时间
	int overtime;   // 进程的完成时间
	int zz;	//进程的周转时间
	double powertime;  // 进程的带权周转时间
};

// 声明排序方法
void paixu(struct homework homeworks[50],int n);
// 声明进程方法
void process(struct homework homeworks[50],int n);
// 声明先来先服务算法
void fcfs(struct homework homeworks[50],int n);
// 声明短进程优先算法
void sjf(struct homework homeworks[50],int n);
// 声明结果输出方法
void printResult(struct homework homeworks[50],int n);

void main(){
	struct homework homeworks[50];
	int n;  // 定义n个进程
	int i;  // i自变量，用于for语句
	
	// 输入进程的个数
	printf("输入进程个数:");
    scanf("%d",&n);
    printf("输入每个进程的进程名,到达时间,服务时间:\n");

	// 循环为每个进程赋初始值
    for(i=0;i<n;i++)
    {
        scanf("%s",homeworks[i].name); //进程名
        scanf("%d",&homeworks[i].arrivetime);//到达时间
        scanf("%d",&homeworks[i].servicetime);//运行（服务时间）时间
    }
    printf("\n");

	// 显示输入的进程的参数
    printf("进程名\t到达时间\t服务时间\n");
    for(i=0;i<n;i++){
		printf("%s\t      %d\t         %d\n",homeworks[i].name,homeworks[i].arrivetime,homeworks[i].servicetime);
    }

	// 先按到达时间先后进行排序
	paixu(homeworks,n);

	// 先来先服务算法：
    fcfs(homeworks,n);
    printf("先来先服务FCFS：\n");
	process(homeworks,n);
    printResult(homeworks,n);

	// 短作业优先算法
    sjf(homeworks,n);
    printf("短作业优先SJF：\n");
	process(homeworks,n);
    printResult(homeworks,n);
}

// 先来先服务
void fcfs(struct homework homeworks[50],int n)
{
   int i; 
   for(i=0;i<n;i++)
   {
    if(i==0) {      //第一个进程
		homeworks[i].starttime=homeworks[i].arrivetime; //开始时间=到达时间
		homeworks[i].overtime=homeworks[i].arrivetime+homeworks[i].servicetime;//完成时间=到达时间+服务时间  
	    homeworks[i].zz=homeworks[i].overtime - homeworks[i].arrivetime;  // 周转时间 = 完成时间 - 到达时间
    }
    else if(homeworks[i].arrivetime>homeworks[i-1].overtime){ //第i个进程到达系统时，第i-1个进程已运行完毕
		homeworks[i].starttime = homeworks[i].arrivetime;               // 开始时间 = 本进程的到达时间
		homeworks[i].overtime = homeworks[i].arrivetime + homeworks[i].servicetime;   // 完成时间=到达时间 + 服务时间
		homeworks[i].zz=homeworks[i].overtime - homeworks[i].arrivetime;     // 周转时间=完成时间-到达时间
    }
    else{ //第i个进程到达系统时，第i-1个进程未运行完毕
		homeworks[i].starttime = homeworks[i-1].overtime;                      // 开始时间 = 上一个进程的完成时间
		homeworks[i].overtime = homeworks[i].starttime + homeworks[i].servicetime;  // 完成时间=开始时间 + 当前进程的服务时间
		homeworks[i].zz=homeworks[i].overtime-homeworks[i].arrivetime; //周转时间= 完成时间 - 到达时间
       
    }
    homeworks[i].powertime=homeworks[i].zz*1.0/homeworks[i].servicetime;       //带权周转时间=周转时间/服务时间
   }
}

// 短作业优先
void sjf(struct homework homeworks[50],int n)
{
   int i=0,j=0,t=0;  // 用作for循环或者a[]的索引
   int x=0,y=0;  // 临时变量，保存a[]的值
   int a[15]={0}; // 存储各等待进程的i位置，
   char temp[10]; // 临时变量，保存homeworks.name的值
   int time;  // 临时变量，保存homeworks.startime,overtime的值          
        
   
   // 计算第一个进程的开始时间、完成时间、周转、带权周转
   homeworks[0].starttime=homeworks[0].arrivetime;
   homeworks[0].overtime=homeworks[0].arrivetime+homeworks[0].servicetime;//完成时间=到达时间+服务时间
   homeworks[0].zz=homeworks[0].servicetime;//周转时间=服务时间
   homeworks[0].powertime=homeworks[0].zz*1.0/homeworks[0].servicetime;//带权周转时间=周转时间/服务时间

   /* 
		思路：（1）第0个进程正在执行，找出等待的都有哪些进程
			  （2）找出等待的进程中谁是首先运行的
			  （3）待第0进程运行结束后，执行第1个进程，即（2）中找出的进程
			  （4）重复执行（1）-（3），直到进程执行完毕
   */

  // 第0个今晨已经知道，找出谁是第1个执行的进程
   for(j=1;j<n;j++){

		// 找出第0个程序运行时，等待的进程都有哪些，从1→n进程中查找
		for(i=j;i<n;i++){
			if(homeworks[i].arrivetime<=homeworks[j-1].overtime) 
				a[t]=i;        //标记各等待进程的索引
				t++;
		}
		// 比较等待进程的服务时间，for循环执行完毕后即可知道谁是第1个运行的程序
		for(i=0;i<t;i++){
			x = a[i];
			y= a[i+1];
			if(homeworks[x].servicetime > homeworks[y].servicetime&&x!=0&&y!=0){
				// 交换进程名字
				strcpy(temp,homeworks[x].name);             //将第二个参数的值复制给第一个参数，返回第一个参数
				strcpy(homeworks[x].name,homeworks[y].name);
				strcpy(homeworks[y].name,temp);
				// 交换到达时间
				time=homeworks[x].arrivetime;
				homeworks[x].arrivetime=homeworks[y].arrivetime;
				homeworks[y].arrivetime=time;
          
				// 交换服务时间
				time=homeworks[x].servicetime;
				homeworks[x].servicetime=homeworks[y].servicetime;
				homeworks[y].servicetime=time;
			}
		}

		// 排完序之后，计算第1个进程的参数
		if(homeworks[j].arrivetime>homeworks[j-1].overtime)//第i个进程到达系统时，第i-1个进程已运行完毕
		{   
			homeworks[j].starttime = homeworks[j].arrivetime; // 开始时间= 到达时间
			homeworks[j].overtime=homeworks[j].arrivetime+homeworks[i].servicetime; //完成时间=到达时间+服务时间
			homeworks[j].zz=homeworks[j].overtime - homeworks[j].arrivetime;//周转时间=完成时间-到达时间
		}
		else  //第i个进程到达系统时，第i-1个进程未执行完毕
		{
			homeworks[j].starttime= homeworks[j-1].overtime;
			homeworks[j].overtime=homeworks[j].starttime+homeworks[j].servicetime;
			homeworks[j].zz=homeworks[j].overtime-homeworks[j].arrivetime; 
		}
		homeworks[j].powertime=homeworks[j].zz*1.0/homeworks[j].servicetime;  
	}
   // 以此类推
}

// 进程简单输出
void process(struct homework homeworks[50],int n){
	int i;
	for(i=0;i<n;i++){
		if(i!=n-1)
			printf("进程%s→",homeworks[i].name);
		else
			printf("进程%s\n",homeworks[i].name);
	}
}

// 输出算法结果
void printResult(struct homework homeworks[50],int n)
{
    int i;
	// 总周转时间
    int sum_zz=0;
	// 总带权周转时间
    double  sum_powertime=0.00;
	// 平均周转时间
    double averzz;
	// 平均带权周转时间
    double averpowertime;
    printf("进程名\t到达时间\t服务时间\t开始时间\t完成时间\t周转时间  带权周转时间\n");
    for(i=0;i<n;i++)
    {
		printf("%s\t     %d\t       %d\t       %d\t       %d\t      %d            %.2f\n",homeworks[i].name,homeworks[i].arrivetime,homeworks[i].servicetime,homeworks[i].starttime,homeworks[i].overtime,homeworks[i].zz,homeworks[i].powertime);
		// 总周转时间
		sum_zz=sum_zz+homeworks[i].zz;
		// 总带权周转时间
		sum_powertime=sum_powertime+homeworks[i].powertime;
    }
	//计算平均数 
    averzz=sum_zz*1.0/n;
    averpowertime=sum_powertime*1.000/n;
    printf("平均周转时间:%.2f \n",averzz);
    printf("平均带权周转时间:%.3f \n",averpowertime);
    printf("\n");
}

// 按到达时间先后进行排序
void paixu(struct homework homeworks[50],int n){
	int i,j=0;  // 循环变量
	int time;  // “中转”变量，类似于temp
	char temp[10];
	// 将进程按到达时间先后顺序进行排序
	for(i=0;i<n;i++){
		for(j=i+1;j<n;j++)
			if(homeworks[i].arrivetime>homeworks[j].arrivetime)  {   
				// 上下交换进程名
				 strcpy(temp,homeworks[i].name);
				 strcpy(homeworks[i].name,homeworks[j].name);
				 strcpy(homeworks[j].name,temp);//在temp数组中排序

				 //交换到达时间
				 time=homeworks[i].arrivetime;
				 homeworks[i].arrivetime=homeworks[j].arrivetime;
				 homeworks[j].arrivetime=time;

				 //交换服务时间
				  time=homeworks[i].servicetime;
				  homeworks[i].servicetime=homeworks[j].servicetime;
				  homeworks[j].servicetime=time;
			}
}
}

运行结果如图所示：

 先来先服务算法FCFS：

 最短作业优先算法SJF：

经过不是很细心的检验，各进程之间的运行顺序没有毛病，有错误的地方各位同学可以在评论区@我，得赶上课去了~