FCFS和SJF进程调度算法实验报告
操作系统进程调度算法模拟实验报告
操作系统进程调度算法模拟实验报告一、实验目的本实验旨在深入理解操作系统的进程调度算法，并通过模拟实验来探究不同调度算法之间的差异和优劣。
二、实验原理操作系统的进程调度算法是决定进程执行顺序的重要依据。
常见的调度算法有先来先服务（FCFS）、最短作业优先（SJF）、优先级调度（Priority Scheduling）、轮转法（Round Robin）和多级反馈队列调度（Multilevel Feedback Queue Scheduling）等。
1.先来先服务（FCFS）算法：按照进程到达的先后顺序进行调度，被调度的进程一直执行直到结束或主动阻塞。
2.最短作业优先（SJF）算法：按照进程需要的执行时间的短长程度进行调度，执行时间越短的进程越优先被调度。
3. 优先级调度（Priority Scheduling）算法：为每个进程分配一个优先级，按照优先级从高到低进行调度。
4. 轮转法（Round Robin）算法：将进程按照到达顺序排列成一个队列，每个进程被分配一个时间片（时间量度），当时间片结束时，将进程从队列头取出放置到队列尾。
5.多级反馈队列调度算法：将进程队列分为多个优先级队列，每个队列时间片大小依次递减。
当一个队列中的进程全部执行完毕或者发生阻塞时，将其转移到下一个优先级队列。
三、实验步骤与结果1.实验环境：- 操作系统：Windows 10- 编译器：gcc2.实验过程：（1）首先，设计一组测试数据，包括进程到达时间、需要的执行时间和优先级等参数。
（2）根据不同的调度算法编写相应的调度函数，实现对测试数据的调度操作。
（3）通过模拟实验，观察不同调度算法之间的区别，比较平均等待时间、完成时间和响应时间的差异。
（4）将实验过程和结果进行记录整理，撰写实验报告。
3.实验结果：这里列举了一组测试数据和不同调度算法的结果，以便对比分析：进程，到达时间，执行时间，优先------，----------，----------，-------P1，0，10，P2，1，1，P3，2，2，P4，3，1，P5，4，5，a.先来先服务（FCFS）算法：平均等待时间：3.8完成时间：15b.最短作业优先（SJF）算法：平均等待时间：1.6完成时间：11c. 优先级调度（Priority Scheduling）算法：平均等待时间：2.8完成时间：14d. 轮转法（Round Robin）算法：时间片大小：2平均等待时间：4.8完成时间：17e.多级反馈队列调度算法：第一级队列时间片大小：2第二级队列时间片大小：4平均等待时间：3.8完成时间：17四、实验总结通过上述的实验结果可以得出以下结论：1.在上述测试数据中，最短作业优先（SJF）算法的平均等待时间最短，说明该算法在短作业的情况下能够有效地减少等待时间。
进程调度实验报告
进程调度实验报告一、实验目的。
本实验旨在通过对进程调度算法的模拟和实验，加深学生对进程调度原理的理解，掌握各种进程调度算法的特点和应用场景，提高学生的实际操作能力和分析问题的能力。
二、实验环境。
本次实验使用了C语言编程语言，通过模拟实现了先来先服务（FCFS）、最短作业优先（SJF）、时间片轮转（RR）和多级反馈队列（MFQ）四种进程调度算法。
三、实验过程。
1. 先来先服务（FCFS）调度算法。
先来先服务调度算法是一种非抢占式的调度算法，按照进程到达的先后顺序进行调度。
在本次实验中，我们通过模拟多个进程到达并排队等待CPU执行，观察其平均等待时间和平均周转时间。
实验结果表明，先来先服务调度算法适用于作业长度差异较大的情况，但容易产生“饥饿”现象。
2. 最短作业优先（SJF）调度算法。
最短作业优先调度算法是一种非抢占式的调度算法，按照作业执行时间的长短进行调度。
在本次实验中，我们通过模拟多个作业的执行时间，观察其平均等待时间和平均周转时间。
实验结果表明，最短作业优先调度算法能够最大程度地减少平均等待时间，但可能会导致长作业被“饿死”。
3. 时间片轮转（RR）调度算法。
时间片轮转调度算法是一种抢占式的调度算法，每个进程被分配一个时间片，当时间片用完后，该进程被放到队尾等待。
在本次实验中，我们通过模拟多个进程的执行和时间片的调度，观察其平均等待时间和平均周转时间。
实验结果表明，时间片轮转调度算法能够保证每个进程都能得到一定的执行时间，但可能会导致上下文切换频繁。
4. 多级反馈队列（MFQ）调度算法。
多级反馈队列调度算法是一种综合性的调度算法，根据进程的优先级和执行时间进行动态调整。
在本次实验中，我们通过模拟多个进程的执行和不同优先级队列的调度，观察其平均等待时间和平均周转时间。
实验结果表明，多级反馈队列调度算法能够兼顾短作业和长作业，提高了系统的整体性能。
四、实验总结。
通过本次实验，我们深入理解了不同进程调度算法的特点和适用场景。
先来先服务调度和最短作业优先调度算法实验报告
先来先服务调度和最短作业优先调度算法实验报告实验报告一、实验目的本实验旨在通过编写代码实现先来先服务调度算法和最短作业优先调度算法，以深入理解和掌握这两种调度算法的原理和实现方法。
二、实验方法和原理1.先来先服务调度算法（FCFS）2.最短作业优先调度算法（SJF）最短作业优先调度算法是根据作业所需的运行时间进行调度的。
当一个作业到达并获得CPU后，系统会选择剩余运行时间最短的作业进行处理，这样可以最大化地提高系统的吞吐量。
三、实验过程与结果1.先来先服务调度算法的实现我们先定义一个作业类Job，其中包含作业名称、到达时间和运行时间等属性。
首先根据到达时间对作业队列进行排序，然后按照顺序执行作业，记录每个作业的开始时间、结束时间和周转时间等指标。
下面是先来先服务调度算法的代码实现部分：```pythonclass Job: = namedef fcfs_scheduler(jobs):for job in sorted_jobs:#创建作业队列jobs =Job("Job1", 0, 3),Job("Job2", 1, 4),Job("Job3", 2, 2),Job("Job4", 4, 1)#调度作业fcfs_scheduler(jobs)#输出结果for job in jobs:```运行以上代码，会得到作业的开始时间、结束时间和周转时间等信息。
2.最短作业优先调度算法的实现最短作业优先调度算法需要知道每个作业的运行时间，而这个信息在实际情况中是未知的。
因此，我们可以先按到达时间对作业队列进行排序，然后在每个时间片中选择剩余运行时间最短的作业进行执行。
下面是最短作业优先调度算法的代码实现部分：```pythondef sjf_scheduler(jobs):while True:if not remaining_jobs:break#创建作业队列jobs =Job("Job1", 0, 3),Job("Job2", 1, 4),Job("Job3", 2, 2),Job("Job4", 4, 1)#调度作业sjf_scheduler(jobs)#输出结果for job in jobs:```运行以上代码，会得到相应的作业调度结果。
FCFS与SJF算法实验报告
先来先服务FCFS和短作业优先SJF进程调度算法学生姓名:学生学号:专业班级:指导老师：2013年6月20日1、实验目的：通过这次实验，加深对进程概念的理解，进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。
2、问题描述：假设有n个进程分别在T1, … ,T n时刻到达系统，它们需要的服务时间分别为S1, … ,S n。
分别采用先来先服务FCFS和短作业优先SJF 进程调度算法进行调度，计算每个进程的完成时间、周转时间和带权周转时间，并且统计n个进程的平均周转时间和平均带权周转时间。
3、需求分析(1) 输入的形式和输入值的范围输入值：进程个数Num 范围：0<Num<=100 依次输入Num个进程的到达时间范围：依次输入Num个进程的服务时间范围：输入要使用的算法范围：1或者2 (2) 输出的形式（X表示变量）时刻X：进程X开始运行。
其完成时间：X周转时间：X带权周转时间：X…（省略（Num-1）个）平均周转时间：X平均带权周转时间：X(3) 程序所能达到的功能输入进程个数Num，每个进程到达时间ArrivalTime[i]，服务时间ServiceTime[i]。
采用先来先服务FCFS或者短作业优先SJF进程调度算法进行调度，计算每个进程的完成时间、周转时间和带权周转时间，并且统计Num个进程的平均周转时间和平均带权周转时间。
4、概要设计（1）程序中进程调度时间变量描述如下：（2）程序流程➢变量初始化；➢接收用户输入n，T1, … ,T n，S1, … ,S n；算法选择1-FCFS，2-SJF；➢按照选择算法进行进程调度，计算进程的完成时间、周转时间和带权周转时间；➢计算所有进程的平均周转时间和平均带权周转时间；按格式输出调度结果。
5、详细设计先来先服务算法：//******************************************************************// 先到先服务算法//******************************************************************void FCFS() //找最早到达的。
实验进程调度的实验报告
一、实验目的1. 加深对进程概念和进程调度算法的理解。
2. 掌握进程调度算法的基本原理和实现方法。
3. 培养编程能力和系统分析能力。
二、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发工具：Visual Studio 2019三、实验内容1. 实现进程调度算法2. 创建进程控制块（PCB）3. 模拟进程调度过程四、实验原理进程调度是操作系统核心功能之一，负责将CPU分配给就绪队列中的进程。
常见的进程调度算法有先来先服务（FCFS）、短作业优先（SJF）、优先级调度、时间片轮转（RR）等。
1. 先来先服务（FCFS）算法：按照进程到达就绪队列的顺序进行调度。
2. 短作业优先（SJF）算法：优先调度运行时间最短的进程。
3. 优先级调度算法：根据进程的优先级进行调度，优先级高的进程优先执行。
4. 时间片轮转（RR）算法：每个进程分配一个时间片，按顺序轮流执行，时间片结束后进行调度。
五、实验步骤1. 定义进程控制块（PCB）结构体，包含进程名、到达时间、运行时间、优先级、状态等信息。
2. 创建进程队列，用于存储就绪队列、等待队列和完成队列。
3. 实现进程调度算法：a. FCFS算法：按照进程到达就绪队列的顺序进行调度。
b. SJF算法：优先调度运行时间最短的进程。
c. 优先级调度算法：根据进程的优先级进行调度。
d. 时间片轮转（RR）算法：每个进程分配一个时间片，按顺序轮流执行。
4. 模拟进程调度过程：a. 初始化进程队列，将进程添加到就绪队列。
b. 循环执行调度算法，将CPU分配给就绪队列中的进程。
c. 更新进程状态，统计进程执行时间、等待时间等指标。
d. 当进程完成时，将其移至完成队列。
六、实验结果与分析1. FCFS算法：按照进程到达就绪队列的顺序进行调度，简单易实现，但可能导致短作业等待时间过长。
2. SJF算法：优先调度运行时间最短的进程，能提高系统吞吐量，但可能导致进程饥饿。
操作系统实验先来先服务FCFS和短作业优先SJF进程调度算法实验报告
:新输人n. n=Z
3
股务时间
完成时I可
周转时间
带权周转时间
服务时问
完成时间
周转时间
带权周转时闾
0
0
0
:Si
日日日
5,6016.60
5,60
21.00
4.80
10,20t|：1-92
弓”輛
17.00
8,00 25,00 10,00
5.OH12-P)a 15.60 23.WH 25-WH
【实验要求】要求如下：
1） 进程个数n;每个进程的到达时间Ti,…，Tn和服务时间Si,…，Sn；选择算法1-FCFS, 2-SJF。
2）要求采用先来先服务FCFS和短作业优先SJF分别调度进程运 行，计算每个进程的周转时间，带权周转时间，并且计算所有进程的 平均周转时间，带权平均周转时间；
3）输出：要求模拟整个调度过程，输出每个时刻的进程运行状态， 如“时刻3:进程B开始运行”等等；
4）输出：要求输出计算出来的每个进程的周转时间，带权周转时 间，所有进程的平均周转时间，带权平均周转时间。
头例截图：
五个进程，到达时间分别为0,134,6
服务时间分别为
设置选择量n,
当
当
当
n不为1或2或3时提示错误，重新输入n；
1-FCFS
n=4
n=l
HS椁的=1选择FCFg&，i|gr^A>,洁重崭淪入I
int timeflyF=0,timeflyS=0;〃定义两个类似于秒表的变量
int j,k, l,n extpro F,n extproS;
//获取数据
for(i=0;ivNumber;i++)
进程调度算法 实验报告
进程调度算法实验报告
《进程调度算法实验报告》
一、实验目的
本实验旨在通过对进程调度算法的实验研究，探究不同调度算法对系统性能的影响，进一步加深对操作系统进程调度的理解。
二、实验内容
本次实验选择了三种常见的进程调度算法，包括先来先服务（FCFS）、最短作业优先（SJF）和轮转调度（RR），并通过模拟不同进程的到达时间和执行时间，分别对这三种算法进行实验比较。
三、实验步骤
1. 设计实验用例：确定不同进程的到达时间和执行时间，以及不同调度算法的时间片大小。
2. 模拟执行：根据设计的实验用例，使用模拟工具模拟不同调度算法的执行过程，并记录每个进程的执行情况和系统的运行情况。
3. 数据分析：根据实验结果，对比不同调度算法的平均等待时间、平均周转时间等指标，分析各算法的优缺点。
四、实验结果
通过实验比较，得出以下结论：
1. 先来先服务（FCFS）算法：适用于执行时间较短的进程，但容易导致长作业等待时间过长。
2. 最短作业优先（SJF）算法：能够最大程度地减少平均等待时间和平均周转时间，但无法处理长作业优先的情况。
3. 轮转调度（RR）算法：能够保证每个进程都能及时得到执行，但可能导致部分进程的等待时间过长。
五、实验结论
根据实验结果，不同的进程调度算法适用于不同的场景。
在实际应用中，需要根据系统的实际情况和需求选择合适的调度算法，以最大程度地提高系统的性能和效率。
六、实验总结
通过本次实验，加深了对进程调度算法的理解，同时也了解了不同算法在实际应用中的优缺点。
希望通过本次实验，能够为进程调度算法的研究和应用提供一定的参考和借鉴。
调度算法的实验报告
一、实验目的1. 理解操作系统调度算法的基本原理和概念。
2. 掌握几种常见调度算法的原理和实现方法。
3. 分析不同调度算法的性能特点，为实际应用提供参考。
二、实验内容本次实验主要涉及以下几种调度算法：先来先服务（FCFS）、最短作业优先（SJF）、优先级调度（Priority Scheduling）、最高响应比优先（HRRN）和时间片轮转（Round Robin）。
1. 先来先服务（FCFS）调度算法FCFS调度算法按照进程到达就绪队列的顺序进行调度，先到达的进程先执行。
该算法简单易实现，但可能导致长作业等待时间过长，从而降低系统吞吐量。
2. 最短作业优先（SJF）调度算法SJF调度算法优先选择执行时间最短的进程进行调度。
该算法可以最大程度地减少平均等待时间和平均周转时间，但可能导致长作业等待时间过长。
3. 优先级调度（Priority Scheduling）算法优先级调度算法为每个进程设置一个优先级，优先选择优先级高的进程进行调度。
该算法可以满足高优先级作业的需求，但可能导致低优先级作业长时间等待。
4. 最高响应比优先（HRRN）调度算法HRRN调度算法为每个进程设置一个响应比，优先选择响应比高的进程进行调度。
响应比是作业的等待时间与作业所需时间的比值。
该算法综合考虑了作业的等待时间和所需时间，是一种较为公平的调度算法。
5. 时间片轮转（Round Robin）调度算法时间片轮转调度算法将CPU时间划分为固定的时间片，按照进程到达就绪队列的顺序，每次只允许一个进程运行一个时间片。
如果进程在一个时间片内无法完成，则将其放入就绪队列的末尾，等待下一次调度。
该算法可以平衡各个进程的执行时间，但可能导致进程响应时间较长。
三、实验步骤1. 编写一个进程调度程序，实现上述五种调度算法。
2. 生成一个包含多个进程的作业队列，每个进程具有到达时间、所需运行时间和优先级等信息。
3. 分别采用五种调度算法对作业队列进行调度，并记录每个进程的执行情况。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
FCFS和SJF进程调度算法实验报告【实验题目】：编写程序，实现FCFS和SJF算法，模拟作业调度过程，加深对作业调度的理解。
【实验内容】实现FCFS和SJF调度算法。
–数据结构设计（JCB，后备作业队列）–算法实现与模拟（排序、调度）–输出调度结果，展示调度过程并解释【实验要求】1. 设计作业控制块(JCB)的数据结构–应包含实验必须的数据项，如作业ID、需要的服务时间、进入系统时间、完成时间，以及实验者认为有必要的其他数据项。
2. 实现排序算法（将作业排队）–策略1：按“进入系统时间”对作业队列排序(FCFS)–策略2：按“需要的服务时间”对作业队列排序（SJF）3. 实现调度过程模拟（1）每个作业用一个JCB表示，如果模拟FCFS，按策略1将作业排队，如果模拟SJF，按策略2将作业排队（2）选择队首的作业，将其从后备队列移出（3）（作业运行过程，在本实验中，无需实现，可认为后备队列的作业一但被调度程序选出，就顺利运行完毕，可以进入第4步）（4）计算选中作业的周转时间（5）进行下一次调度（去往第2步）4.实现结果输出–输出作业状态表，展示调度过程•初始作业状态（未调度时）•每次调度后的作业状态设计作业控制块(JCB)的数据结构每个作业由一个作业控制块JCB表示，JCB可以包含如下信息：作业名、提交时间、所需的运行时间、所需的资源、作业状态、链指针等等。
具体结构如下：typedef struct jcb{char name[10]; /* 作业名*/char state; /* 作业状态*/int ts; /* 提交时间*/float super; /* 优先权*/int tb; /* 开始运行时间*/int tc; /* 完成时间*/float ti; /* 周转时间*/float wi; /* 带权周转时间*/int ntime; /* 作业所需运行时间*/char resource[10]; /* 所需资源*/struct jcb *next; /* 结构体指针*/} JCB;JCB *p,*tail=NULL,*head=NULL;作业的状态可以是等待W(Wait)、运行R(Run)和完成F(Finish)三种状态之一。
每个作业的最初状态总是等待W。
，组成一个后备队列等待，总是首先调度等待队列中队首的作业。
本实验采用链表的形式存放各后备队列当中的作业控制块，各个等待的作业按照提交时刻的先后次序排队。
当一个作业进入系统时，就为其动态建立一作业控制块（JCB），挂入后备队列尾部。
当作业调度时，从后备队列中按某种调度算法选择一作业，让其进入主存以便占用CPU执行。
每个作业完成后要打印该作业的开始运行时刻、完成时刻、周转时间和带权周转时间，这一组作业完成后要计算并打印这组作业的平均周转时间、带权平均周转时间。
程序代码：#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].wancheng<<" ";cout<<setw(10)<<setiosflags(ios::fixed)<<setprecision(2)<<process[i].zhouzhuan<<" ";cout<<setw(10)<<setiosflags(ios::fixed)<<setprecision(2)<<process[i].daiquan<<" "<<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;}}实例截图：五个进程，到达时间分别为8,21,9,18,6服务时间分别为10,4,16,22,9设置选择量n，当n=1时，选择FCFS当n=2时，选择SJF当n=3时，同时分别调用FCFS和SJFn不为1或2或3时提示错误，重新输入n；1-FCFS 算法2-SJF算法3同时调用FCFS和SJF。