操作系统_进程调度算法（FCFS）

操作系统_处理器管理_先到先服务算法：

问题描述：

输入N(N>0)个作业，输入每个作业的名字，到达时间，服务时间，按照先来先服务算法，计算每个作业的完成时间，周转时间，带权周转时间（保留2位小数）。

输入格式:
第一行输入作业数目，第二行输入作业的名字，第三行输入到达时间，第四行输入服务时间。

输出格式:
按照到达时间从小到大排序，第一行输出作业的名字，第二行输出到达时间，第三行输出服务时间，第四行输出完成时间，第五行输出完成时间，第六行输出带权周转时间。
下面展示一些.

输入样例:
在这里给出一组输入。
例如：
5
A B C D E
0 1 2 3 4
4 3 4 2 4
输出样例:
在这里给出相应的输出。
例如：
作 业 名：A B C D E
到达时间：0 1 2 3 4
服务时间：4 3 4 2 4
完成时间：4 7 11 13 17
周转时间：4 6 9 10 13
带权周转时间：1.00 2.00 2.25 5.00 3.25

FCFS算法

只对先到的作业先服务，因此，对于先到的作业能最早的得到资源并进行运算。

代码展示：

#include <bits/stdc++.h>
using namespace std;

struct  process{
    char name[16];	//名字 
    double come_time; 	//到达时间 
    double run_time;	//运行时间 
    double finish_time;	//完成时间 
    double circle_time;	//周转时间 
    double weight_circletime;	//带权周转时间 
    int  finished;		//程序是否被执行（0）为未被执行，反之已经执行 
}P[1024];

int n; // 输入进去n个进程 
//输入 
void Input(){ 
    cin>>n;
    for(int i=0;i<n;i++){
        cin>>P[i].name;
		P[i].finished = 0;//输入进去的程序都是未被执行的 
    }
    for(int i=0;i<n;i++){
        cin>>P[i].come_time;
    }
    for(int i=0;i<n;i++){
        cin>>P[i].run_time;
    }
}
//输出 
void Output(){
    printf("作 业 名：");
    for(int i=0;i<n;i++){
        
		cout<<P[i].name;
		if(i<n-1){
			printf(" "); 
		}
    }
    printf("\n");
    printf("到达时间：");
    for(int i=0;i<n;i++){
        cout<<P[i].come_time;
        	if(i<n-1){
			printf(" "); 
		}
	}
		
    
    printf("\n");
    printf("服务时间：");
    for(int i=0;i<n;i++){
        cout<<P[i].run_time;
        	if(i<n-1){
			printf(" "); 
		}
	}

    printf("\n");
    printf("完成时间：");
    for(int i=0;i<n;i++){
        cout<<P[i].finish_time; 
        	if(i<n-1){
			printf(" "); 
		}
		}
    
    printf("\n");
    printf("周转时间：");
    for(int i=0;i<n;i++){
        cout<<P[i].circle_time;
        	if(i<n-1){
			printf(" "); 
		}
		}
    
    printf("\n");
    printf("带权周转时间：");
    for(int i=0;i<n;i++){
       printf("%.2f",P[i].weight_circletime);
	    if(i < n-1) {
			printf(" ");
			}
    }
    
}
bool cmp(process p1,process p2){     //将到达的进程按照到达时间进行排序 
	    return p1.come_time<p2.come_time;
}
int main(){
	Input();
	sort(P,P+n,cmp);
	double now_time;
	int finish_count = 0;
	int unfinish_pos = 0;
	while(finish_count<n){ 
		if(now_time<P[unfinish_pos].come_time){
			now_time = P[unfinish_pos].come_time; //对now_time进行更新 
		}
		for(int i = unfinish_pos;(i < n && now_time >= P[i].come_time);i++){// now_time >= P[i].come_time确保是之前已经到了的处于等待中的作业 
			if(P[i].finished == 1) continue ;			
		}
			now_time = now_time + P[unfinish_pos].run_time;//对于先到的作业先运算 
			P[unfinish_pos].finish_time = now_time;
			P[unfinish_pos].circle_time = now_time - P[unfinish_pos].come_time;
			P[unfinish_pos].weight_circletime = P[unfinish_pos].circle_time / P[unfinish_pos].run_time;
			P[unfinish_pos].finished = 1;
		unfinish_pos ++;
		finish_count++;
	}
	Output();
	return 0;
} 

测试结果：