操作系统先来先服务

先来先服务和优先数调度算法c语言先来先服务和优先数调度算法c语言一、前言操作系统中的进程调度是指在多道程序环境下，按照一定的规则从就绪队列中选择一个进程，将CPU分配给它运行。

常用的进程调度算法有先来先服务（FCFS）、最短作业优先（SJF）、时间片轮转（RR）等。

本文将介绍两种常见的进程调度算法：先来先服务和优先数调度算法，并给出相应的C语言实现。

二、先来先服务算法1. 算法原理FCFS即First Come First Served，也称为FIFO（First In First Out），是一种非抢占式的进程调度算法。

按照任务到达时间的顺序进行处理，即谁先到达谁就被处理。

2. 算法流程（1）按照任务到达时间排序；（2）依次执行每个任务，直至所有任务都完成。

3. C语言实现下面是一个简单的FCFS程序：```c#include <stdio.h>struct process {int pid; // 进程IDint arrival_time; // 到达时间int burst_time; // 执行时间int waiting_time; // 等待时间};int main() {struct process p[10];int n, i, j;float avg_waiting_time = 0;printf("请输入进程数：");scanf("%d", &n);for (i = 0; i < n; i++) {printf("请输入第%d个进程的信息：\n", i + 1); printf("进程ID：");scanf("%d", &p[i].pid);printf("到达时间：");scanf("%d", &p[i].arrival_time);printf("执行时间：");scanf("%d", &p[i].burst_time);}for (i = 0; i < n; i++) {for (j = 0; j < i; j++) {if (p[j].arrival_time > p[j + 1].arrival_time) { struct process temp = p[j];p[j] = p[j + 1];p[j + 1] = temp;}}}int current_time = p[0].arrival_time;for (i = 0; i < n; i++) {if (current_time < p[i].arrival_time) {current_time = p[i].arrival_time;}p[i].waiting_time = current_time - p[i].arrival_time;current_time += p[i].burst_time;}printf("进程ID\t到达时间\t执行时间\t等待时间\n");for (i = 0; i < n; i++) {printf("%d\t%d\t%d\t%d\n", p[i].pid, p[i].arrival_time, p[i].burst_time, p[i].waiting_time);avg_waiting_time += (float)p[i].waiting_time / n;}printf("平均等待时间：%f\n", avg_waiting_time);return 0;}```三、优先数调度算法1. 算法原理优先数调度算法是一种非抢占式的进程调度算法。

操作系统中的进程调度与资源分配算法在操作系统中，进程调度与资源分配算法是实现多任务并发执行的关键。

进程调度算法决定了哪些进程有权利使用CPU，并且在何时和多长时间内使用；而资源分配算法则决定了如何分配和管理系统中的资源，以满足进程的需要。

本文将探讨几种常见的进程调度与资源分配算法。

一、先来先服务（First-Come, First-Served）算法先来先服务是最简单的进程调度算法之一，它按照进程到达的顺序进行调度。

具体来说，当一个进程抵达系统时，系统会为其分配CPU，并且一直运行直到该进程结束或者发生阻塞。

这种算法的优点是简单易实现，但是存在长作业等待时间长的缺点。

二、短作业优先（Shortest Job First）算法短作业优先算法是基于任务的执行时间来进行调度的。

在该算法中，系统会选择最短执行时间的进程来先运行。

这样可以最大限度地减少平均等待时间，提高系统的响应速度。

然而，此算法需要预先知道每个进程的执行时间，而且对于长作业而言，存在“饥饿”的问题。

三、最高优先级（Highest Priority）算法最高优先级算法将每个进程赋予一个优先级，CPU将会优先调度优先级最高的进程。

这种算法可以确保紧急任务或重要任务得到及时的处理，但是当优先级存在相差较大的情况下，需要小心避免低优先级任务的饥饿问题。

四、时间片轮转（Round-Robin）算法时间片轮转算法把每个进程分配一个固定的时间片，例如10毫秒，每个进程运行一段时间后就切换到下一个进程，循环进行。

这种算法公平地分配CPU时间，并且能够有效避免长作业等待时间长的问题。

但是，如果时间片设置过小，会导致进程切换过于频繁，系统开销较大。

反之，设置过大可能会影响系统的响应速度。

资源分配算法也是操作系统中至关重要的一部分，下面列举几种常见的资源分配算法。

一、固定分配（Fixed Allocation）算法固定分配算法将系统的资源按比例分配给不同的进程。

操作系统实验_先来先服务的调度算法及短作业优先1.引言操作系统的调度算法是指在多进程环境中，操作系统为进程分配CPU 的顺序和策略。

先来先服务（FCFS）调度算法是最简单的调度算法之一，它按照进程到达的顺序为其分配CPU。

而短作业优先（SJF）调度算法是根据进程的执行时间来为其分配CPU，执行时间越短的进程越先执行。

本文将分别介绍FCFS调度算法和SJF调度算法，并对其进行评价和比较。

2.先来先服务（FCFS）调度算法2.1调度原理FCFS调度算法的原理非常简单，按照进程到达的顺序为其分配CPU。

当一个进程进入就绪队列后，如果CPU空闲，则立即为其分配CPU。

如果CPU正忙，则进程进入等待队列，等待CPU空闲后再分配。

在该算法中，进程的运行时间不考虑，只考虑进程到达的时间。

2.2优点与缺点FCFS调度算法的主要优点是实现简单，无需对进程的运行时间进行估计。

但FCFS算法存在一定的缺点。

首先，长作业在短作业前面等待的时间较长，可能导致长作业的响应时间过长。

其次，如果有一个进程出现阻塞或响应时间过长，其后面的进程也会受到影响，造成整个系统的性能下降。

3.短作业优先（SJF）调度算法3.1调度原理短作业优先（SJF）调度算法是根据进程的执行时间来为其分配CPU。

当一个进程进入就绪队列后，如果其执行时间比当前正在运行的进程短，则优先为该进程分配CPU。

如果当前没有运行的进程或者当前运行的进程执行完毕，则立即为该进程分配CPU。

在该算法中，进程的到达时间不考虑，只考虑进程的执行时间。

3.2优点与缺点SJF调度算法的主要优点是可以最大程度地减少平均等待时间，提高系统的吞吐量。

短作业可以快速执行完毕，从而让更多的作业得以执行。

但SJF算法存在一定的缺点。

首先，需要对进程的执行时间有一个准确的估计，对于实时系统或动态系统来说，估计执行时间可能会有一定的误差。

其次，在长作业激增的情况下，短作业可能会一直得不到CPU的分配，造成长时间的等待。

操作系统中常用作业调度算法的分析作业调度是操作系统中的一个重要组成部分，它负责对待执行的作业进行排队和调度，以最大化系统资源的利用效率、满足用户需求、保证系统稳定性等目标。

常见的作业调度算法有先来先服务（FCFS）、最短作业优先（SJF）、优先级调度、时间片轮转（RR）等，接下来我们分别对这几种算法进行分析。

1. FCFS调度算法先来先服务调度算法是操作系统中最简单的一种调度算法，也是最常用的一种调度算法。

它的处理方式是根据提交时间顺序，按照FIFO的顺序进行调度。

该算法的优点是简单易用，而且很容易实现。

同时，对于大多数情况下，该算法的资源分配相对公平。

但是，该算法存在着一些问题。

当一个作业的执行时间较长时，会大大降低系统的吞吐量，严重影响系统的效率。

因此，在实际应用中，该算法往往不能满足对作业的实时响应和高效完成的要求。

最短作业优先调度算法是一种非抢占式调度算法，它将作业按照其需要执行的时间长短大小进行排序，然后从执行时间最短的作业开始调度。

在实际应用中，该算法可以减少平均等待时间和平均周转时间，提高系统的效率和性能。

但是，该算法有个致命的缺点——它无法预测作业的执行时间。

如果一个长作业被排在了等待队列的前面，那么所有后续的短作业都要等待非常长的时间，这可能导致饥饿现象的出现。

3. 优先级调度算法优先调度算法是一种根据作业优先级大小进行调度的算法，可以根据作业的重要程度或紧急程度来设置不同的优先级。

该算法可以提高系统的响应速度和稳定性，满足系统特定的需求。

但是，该算法也存在着一些问题。

如果一个作业的优先级太高，那么其余的作业可能会一直处于等待状态，这种情况也会导致饥饿现象的出现。

此外，该算法的优先级设置需要有一定的经验和技巧，否则可能会对系统的性能产生不良影响。

4. 时间片轮转算法时间片轮转算法是一种循环调度算法，它将CPU的时间分成多个固定大小的时间片，然后在每个时间片内轮流执行等待队列中的作业，以便平均分配CPU资源。

操作系统有哪些主要调度算法操作系统调度算法一、磁盘调度1.先来先服务fcfs：是按请求访问者的先后次序启动磁盘驱动器，而不考虑它们要访问的物理位置2.最短一般说来时间优先sstf：使距当前磁道最近的命令访问者启动磁盘驱动器，即是使查找时间最短的那个作业先继续执行，而不考量命令访问者到来的先后次序，这样就消除了先来先服务调度算法中磁臂移动过小的问题3.扫描算法scan或电梯调度算法：总是从磁臂当前位置开始，沿磁臂的移动方向去选择离当前磁臂最近的那个柱面的访问者。

如果沿磁臂的方向无请求访问时，就改变磁臂的移动方向。

在这种调度方法下磁臂的移动类似于电梯的调度，所以它也称为电梯调度算法。

4.循环读取算法cscan：循环读取调度算法就是在读取算法的基础上改良的。

磁臂改成单项移动，由外向里。

当前边线已经开始沿磁臂的移动方向回去挑选距当前磁臂最近的哪个柱面的访问者。

如果沿磁臂的方向并无命令出访时，再返回最外，出访柱面号最轻的作业命令。

操作系统调度算法二、进程调度算法1.先进先出算法fifo：按照进程步入准备就绪队列的先后次序去挑选。

即为每当步入进程调度，总是把准备就绪队列的队首进程资金投入运转。

2.时间片轮转算法rr：分时系统的一种调度算法。

轮转的基本思想是，将cpu的处理时间划分成一个个的时间片，就绪队列中的进程轮流运行一个时间片。

当时间片结束时，就强迫进程让出cpu，该进程进入就绪队列，等待下一次调度，同时，进程调度又去选择就绪队列中的一个进程，分配给它一个时间片，以投入运行。

3.最低优先级算法hpf：进程调度每次将处理机分配给具备最低优先级的准备就绪进程。

最低优先级算法可以与相同的cpu方式融合构成可以抢占市场式最低优先级算法和不容抢占市场式最低优先级算法。

4.多级队列反馈法：几种调度算法的结合形式多级队列方式。

操作系统调度算法三、常用的批处理作业调度算法1.先来先服务调度算法fcfs:就是按照各个作业进入系统的自然次序来调度作业。

操作系统实验_先来先服务的调度算法及短作业优先先来先服务调度算法是一种非抢占式的调度算法，它按照作业到达的先后顺序将作业分配给CPU。

具体来说，当一个作业进入就绪队列时，调度程序将把它放在队列的末尾，然后从队列的头部选择一个作业执行。

只有当一个作业执行完成后，作业队列的头部才会选择下一个作业执行。

先来先服务调度算法的优点是简单易实现，没有复杂的排序操作，适用于短作业和长作业混合的场景。

其缺点是没有考虑作业的执行时间，导致长作业会占用CPU很长时间，影响其他作业的响应时间。

短作业优先调度算法是一种抢占式的调度算法，它根据作业的执行时间选择优先级。

具体来说，当一个作业进入就绪队列时，调度程序会比较该作业的执行时间和其他就绪作业的执行时间，并选择执行时间最短的作业执行。

如果有一个新的作业到达，且其执行时间比当前执行的作业要短，那么调度程序会中断当前作业的执行并切换到新的作业执行。

短作业优先调度算法的优点是能够最大程度上减少作业的等待时间和响应时间，提高系统的吞吐量。

其缺点是需要对作业的执行时间有较准确的估计，否则可能导致长作业陷入饥饿状态。

此外，由于需要频繁进行作业的切换，短作业优先调度算法在实现上相对复杂。

在实际应用中，先来先服务调度算法适用于短作业和长作业混合的场景，或者作业的执行时间无法估计准确的情况下。

例如，在批处理系统中，作业的执行时间往往是固定的，先来先服务调度算法可以保证公平性，并且能够有效利用CPU资源。

而短作业优先调度算法适用于多任务环境下，作业的执行时间可以估计准确的情况下。

例如，在交互式系统中，用户的操作往往是短暂的，短作业优先调度算法可以最大限度地减少用户的等待时间，提高系统的响应速度。

总之，先来先服务调度算法和短作业优先调度算法是操作系统中常用的两种调度算法。

它们分别适用于不同的应用场景，在实际应用中可以根据具体需求选择不同的调度算法。

几种操作系统调度算法操作系统调度算法是操作系统中用于确定进程执行的顺序和优先级的一种方法。

不同的调度算法有不同的优缺点，适用于不同的场景和需求。

下面将介绍几种常见的操作系统调度算法：1.先来先服务（FCFS）调度算法:先来先服务调度算法是最简单的调度算法之一、按照进程到达的顺序进行调度，首先到达的进程先执行，在CPU空闲时执行下一个进程。

这种算法实现简单，并且公平。

但是，由于没有考虑进程的执行时间，可能会导致长作业时间的进程占用CPU资源较长时间，从而影响其他进程的响应时间。

2.短作业优先（SJF）调度算法:短作业优先调度算法是根据进程的执行时间进行排序，并按照执行时间最短的进程优先执行。

这种算法可以减少平均等待时间，提高系统的吞吐量。

然而，对于长作业时间的进程来说，等待时间会相对较长。

3.优先级调度算法:优先级调度算法是根据每个进程的优先级来决定执行顺序的。

优先级可以由用户设置或者是根据进程的重要性、紧迫程度等因素自动确定。

具有较高优先级的进程将具有更高的执行优先级。

这种算法可以根据不同情况进行灵活调度，但是如果不恰当地设置优先级，可能会导致低优先级的进程长时间等待。

4.时间片轮转（RR）调度算法:时间片轮转调度算法将一个固定的时间片分配给每个进程，当一个进程的时间片用完时，将该进程挂起，调度下一个进程运行。

这种算法可以确保每个进程获得一定的CPU时间，提高系统的公平性和响应速度。

但是，对于长时间运行的进程来说，可能会引起频繁的上下文切换，导致额外的开销。

5.多级反馈队列（MFQ）调度算法:多级反馈队列调度算法将进程队列划分为多个优先级队列，每个队列有不同的时间片大小和优先级。

新到达的进程被插入到最高优先级队列，如果进程在时间片内没有完成，则被移到下一个较低优先级队列。

这种算法可以根据进程的执行表现自动调整优先级和时间片，更好地适应动态变化的环境。

以上是几种常见的操作系统调度算法，每种算法都有其优缺点和适用场景。

操作系统五种进程调度算法的代码一、先来先服务（FCFS）调度算法先来先服务（FCFS）调度算法是操作系统处理进程调度时比较常用的算法，它的基本思想是按照进程的提交时间的先后顺序依次调度进程，新提交的进程会在当前运行进程之后排队，下面通过C语言代码来实现先来先服务（FCFS）调度算法：#include <stdio.h>#include <stdlib.h>//定义进程的数据结构struct Processint pid; // 进程标识符int at; // 到达时间int bt; // 执行时间};//进程调度函数void fcfs_schedule(struct Process *processes, int n)int i, j;//根据进程的到达时间排序for(i = 0; i < n; i++)for(j = i+1; j < n; j++)if(processes[i].at > processes[j].at) struct Process temp = processes[i]; processes[i] = processes[j];processes[j] = temp;//获取各个进程执行完毕的时间int ct[n];ct[0] = processes[0].at + processes[0].bt; for(i = 1; i < n; i++)if(ct[i-1] > processes[i].at)ct[i] = ct[i-1] + processes[i].bt;elsect[i] = processes[i].at + processes[i].bt; //计算各个进程的周转时间和带权周转时间int tat[n], wt[n], wt_r[n];for(i = 0; i < n; i++)tat[i] = ct[i] - processes[i].at;wt[i] = tat[i] - processes[i].bt;wt_r[i] = wt[i] / processes[i].bt;printf("P%d:\tAT=%d\tBT=%d\tCT=%d\tTAT=%d\tWT=%d\tWT_R=%f\n", processes[i].pid, processes[i].at, processes[i].bt, ct[i], tat[i], wt[i], wt_r[i]);//主函数int mainstruct Process processes[] ={1,0,3},{2,3,5},{3,4,6},{4,5,2},{5,6,4}};fcfs_schedule(processes, 5);return 0;输出：。

【操作系统】先来先服务和短作业优先算法（C语⾔实现）【操作系统】先来先服务算法和短作业优先算法实现介绍:1.先来先服务 (FCFS: first come first service)如果早就绪的进程排在就绪队列的前⾯，迟就绪的进程排在就绪队列的后⾯，那么先来先服务(FCFS: first come first service)总是把当前处于就绪队列之⾸的那个进程调度到运⾏状态。

也就说，它只考虑进程进⼊就绪队列的先后，⽽不考虑它的下⼀个CPU周期的长短及其他因素。

FCFS算法简单易⾏，是⼀种⾮抢占式策略，但性能却不⼤好。

简单来说，先来先服务就是那个进程到达时间最早，那么CPU就先处理哪个进程。

2.短作业优先（SJF, Shortest Job First）对预计执⾏时间短的作业（进程）优先分派处理机。

通常后来的短作业不抢先正在执⾏的作业。

也就是说，不但要考虑进程的到达时间，还要考虑进程需要运⾏的时间。

当⼀个进程正在运⾏时，假如有其他的进程到达，那么这些到达的进程就需要按照其需要运⾏的时间长短排序，运⾏时间短的在前，运⾏时间长的在后。

3.例⼦：4.运⾏截图1.先来先服务2.短作业优先5.话不多说，直接上代码。

第⼀次写，有很多不⾜的地⽅。

希望⼤家看到可以帮忙纠正⼀下，谢谢⼤家。

#include <stdio.h>#include <stdlib.h>#define MAX 10typedef struct PCB {int id,arrive_time,service_time,start_time,finish_time; //进程id、到达时间、服务时间、开始时间、完成时间float zhouzhuan_time,daiquanzhouzhuan_time; //周转时间、带权周转时间。

只能说我的拼英。

emm，。

尴尬。

int status;}PCB;typedef enum {OK,ERROR}Status;typedef enum {FALSE,TRUE}Bool;typedef PCB datatype;typedef struct LinkQueue {int front;int rear;int length;datatype* base;}quene;int arrive[MAX]; // 记录每个作业的到达时间int service[MAX]; //记录每个作业的服务时间int num; //输⼊的进程个数quene init(){quene q_pcb;q_pcb.base = (datatype *)malloc(sizeof(datatype)*MAX);q_pcb.front = q_pcb.rear = 0;q_pcb.length = 0;return q_pcb;}Bool isFull(quene *q) {if ((q->rear + 1) % MAX == q->front) {return TRUE;}return FALSE;}Bool isEmpty(quene *q) {if (q->rear == q->front) {return TRUE;}return FALSE;}Status rudui(quene *q,datatype p){ //⼊队。

最新最全的先来先服务FCFS和短作业优先SJF进程调度算法【实验题目】：先来先服务FCFS和短作业优先SJF进程调度算法通过这次实验，加深对进程概念的理解，进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。

【实验内容】问题描述：设计程序模拟进程的先来先服务FCFS和短作业优先SJF调度过程。

假设有n个进程分别在T1, …,T n时刻到达系统，它们需要的服务时间分别为S1, … ,S n。

分别采用先来先服务FCFS和短作业优先SJF 进程调度算法进行调度，计算每个进程的完成时间，周转时间和带权周转时间，并且统计n个进程的平均周转时间和平均带权周转时间。

【实验要求】要求如下：1）进程个数n；每个进程的到达时间T1, …,T n和服务时间S1, … ,S n；选择算法1-FCFS，2-SJF。

2）要求采用先来先服务FCFS和短作业优先SJF分别调度进程运行，计算每个进程的周转时间，带权周转时间，并且计算所有进程的平均周转时间，带权平均周转时间；3）输出：要求模拟整个调度过程，输出每个时刻的进程运行状态，如“时刻3：进程B开始运行”等等；4）输出：要求输出计算出来的每个进程的周转时间，带权周转时间，所有进程的平均周转时间，带权平均周转时间。

程序代码：#include<iostream.h>#include<iomanip.h>#define Number 5void main(){int n;int daoda[Number],fuwu[Number],i;cout<<"请依次输入各个进程的到达时间并以空格间隔:";for(i=0;i<Number;i++){cin>>daoda[i];}cout<<"请依次输入各个进程的服务时间，并以空格间隔:";for(i=0;i<Number;i++){cin>>fuwu[i];}cout<<"请输入n=1选择FCFS或者n=2选择SJF或者n=3同时调用FCFS 和SJF,n=";cin>>n;while(n<1||n>3){cout<<"输入的n有误，请重新输入n，n=";cin>>n;}struct statedd //声明结构{bool doneF,doneS;int daoda,fuwu;float wancheng,zhouzhuan,daiquan,wan,zhou,dai;};statedd process[Number];//声明结构变量，这里为数组int timeflyF=0,timeflyS=0;//定义两个类似于秒表的变量int j,k,l,nextproF,nextproS;// 获取数据for(i=0;i<Number;i++){process[i].doneF = false;process[i].doneS = false;process[i].wancheng = 0;process[i].zhouzhuan = 0;process[i].daiquan = 0;process[i].wan = 0;process[i].zhou = 0;process[i].dai =0;process[i].daoda = daoda[i];process[i].fuwu = fuwu[i];}// 获取最先到达的进程下标firstint first=0;l=first;for(i=1;i<Number;i++){if(daoda[first]>daoda[i])first=i;}process[first].doneF=true;process[first].doneS=true;process[first].wancheng = process[first].fuwu + process[first].daoda;process[first].wan = process[first].fuwu + process[first].daoda;timeflyF += process[first].daoda+process[first].fuwu;timeflyS += process[first].daoda+process[first].fuwu;// 接下去到达的进程//************************************************************* // fcfs ******************************************************** for(j=1;j<Number;j++){nextproF = Number+1;for(k =0 ; k<Number; k++ ){if( !process[k].doneF ){if( process[k].daoda <= timeflyF ) // 到达{if( nextproF ==Number+1)nextproF = k;else{if( process[nextproF].daoda > process[k].daoda )nextproF = k; //获取到达时刻最先的进程}//else}//if2}//if1}//for// 处理process[nextproF].wancheng = process[nextproF].fuwu + timeflyF;timeflyF += process[nextproF].fuwu;process[nextproF].doneF=true;} // circle2// SJF **********************************************for(j=1;j<Number;j++){nextproS = Number+1;for(k=0 ; k<Number; k++ ){if(!process[k].doneS){if( process[k].daoda <= timeflyS ) // 到达{if( nextproS ==Number+1 )nextproS = k;else{if( process[nextproS].fuwu > process[k].fuwu )nextproS = k; //获取服务时间最小的进程}//else}//if2}//if1}//for// 处理process[nextproS].wan = process[nextproS].fuwu + timeflyS;timeflyS += process[nextproS].fuwu;process[nextproS].doneS=true;} // circle2//**************************************************************** float Fz=0,Fdq=0,Sz=0,Sdq=0;//for(i=0;i<Number;i++){ //----------------------------------------------------process[i].zhouzhuan=process[i].wancheng-process[i].daoda;Fz += process[i].zhouzhuan;process[i].daiquan=process[i].zhouzhuan/process[i].fuwu;Fdq += process[i].daiquan;//----------------------------------------------------process[i].zhou=process[i].wan-process[i].daoda;Sz += process[i].zhou;process[i].dai=process[i].zhou/process[i].fuwu;Sdq += process[i].dai;}//=========================输出==================================//-------------------------------------------------------------------if(n==1||n==3){cout<<"\t"<<endl;cout<<"FCFS:"<<endl;for(i=0;i<Number;i++){if(i<1){cout<<"时刻"<<l<<":进程"<<i+1<<"在运行"<<endl;}else{cout<<"时刻"<<process[i-1].wancheng<<":进程"<<i+1<<"在运行"<<endl;}}cout<<setw(10)<<"进程ID"<<" ";cout<<setw(10)<<"完成时间"<<" ";cout<<setw(10)<<"周转时间"<<" ";cout<<setw(10)<<"带权周转时间"<<" "<<endl;for(i=0;i<Number;i++){cout<<setw(10)<<i+1<<" ";cout<<setw(10)<<setiosflags(ios::fixed)<<setprecision(2)<<process[i].wanc heng<<" ";cout<<setw(10)<<setiosflags(ios::fixed)<<setprecision(2)<<process[i].zhouz huan<<" ";cout<<setw(10)<<setiosflags(ios::fixed)<<setprecision(2)<<process[i].daiqu an<<" "<<endl;}cout<<"平均周转时间为："<<setiosflags(ios::fixed)<<setprecision(2)<<Fz/Number<<endl;cout<<"平均带权周转时间为："<<setiosflags(ios::fixed)<<setprecision(2)<<Fdq/Number<<endl;}//-------------------------------------------------------------------if(n==2||n==3){cout<<"\t"<<endl;cout<<"SJF:"<<endl;for(i=0;i<Number;i++){if(i<1){cout<<"时刻"<<l<<":进程"<<i+1<<"在运行"<<endl;}else{cout<<"时刻"<<process[i-1].wan<<":进程"<<i+1<<"在运行"<<endl;}}cout<<setw(10)<<"进程ID"<<" ";cout<<setw(10)<<"完成时间"<<" ";cout<<setw(10)<<"周转时间"<<" ";cout<<setw(10)<<"带权周转时间"<<" "<<endl;for(i=0;i<Number;i++){cout<<setw(10)<<i+1<<" ";cout<<setw(10)<<setiosflags(ios::fixed)<<setprecision(2)<<process[i].wan< <" ";cout<<setw(10)<<setiosflags(ios::fixed)<<setprecision(2)<<process[i].zhou< <" ";cout<<setw(10)<<setiosflags(ios::fixed)<<setprecision(2)<<process[i].dai<< " "<<endl;}cout<<"平均周转时间为："<<setiosflags(ios::fixed)<<setprecision(2)<<Sz/Number<<endl;cout<<"平均带权周转时间为："<<setiosflags(ios::fixed)<<setprecision(2)<<Sdq/Number<<endl;cout<<"\t"<<endl;}}实例截图：五个进程，到达时间分别为0,1,3,4,6服务时间分别为5,7,3,8,2设置选择量n，当n=1时，选择FCFS当n=2时，选择SJF当n=3时，同时分别调用FCFS和SJFn不为1或2或3时提示错误，重新输入n；1-FCFS 算法2-SJF算法3同时调用FCFS和SJF。