经典调度算法的实现
用于作业调度的算法
用于作业调度的算法作业调度是计算机操作系统中的一个重要概念，它指的是在多个进程同时运行时，如何合理地分配CPU资源，使得系统能够高效地完成各项任务。
作业调度算法是实现作业调度的关键，下面将详细介绍几种常见的作业调度算法。
一、先来先服务（FCFS）算法先来先服务（FCFS）算法是最简单也是最容易实现的一种作业调度算法。
该算法按照进程到达时间的顺序依次执行，即当一个进程到达后，如果当前没有正在执行的进程，则立即执行该进程；否则将该进程加入等待队列中，并等待前面所有进程执行完毕后再进行处理。
FCFS算法优点在于简单易实现，并且保证了公平性。
但由于没有考虑到不同进程的优先级和执行时间等因素，因此可能会导致长任务等待时间过长、短任务响应时间过长等问题。
二、短作业优先（SJF）算法短作业优先（SJF）算法是一种根据作业长度进行排序的调度策略。
该算法按照各个进程需要占用CPU时间片长度进行排序后依次执行，即当一个新的进程到达时，如果其需要占用的时间片长度比当前正在执行的进程短，则立即切换到该进程进行处理，否则将该进程加入等待队列中，并等待前面所有进程执行完毕后再进行处理。
SJF算法优点在于能够最大限度地缩短作业响应时间，提高系统的吞吐量。
但由于需要预测每个进程需要占用的时间片长度，因此实现起来较为困难，并且可能会出现“饥饿”现象，即长时间等待CPU资源的进程无法得到及时处理。
三、优先级调度算法优先级调度算法是一种按照不同进程的优先级进行排序的调度策略。
该算法将每个进程赋予一个优先级值，根据优先级值高低依次执行，即当一个新的进程到达时，如果其优先级比当前正在执行的进程高，则立即切换到该进程进行处理，否则将该进程加入等待队列中，并等待前面所有优先级更高的进程执行完毕后再进行处理。
优先级调度算法可以根据不同任务类型和紧急性进行灵活调整，并且可以避免长任务等待时间过长、短任务响应时间过长等问题。
但由于可能会出现“饥饿”现象和优先级反转等问题，因此需要进行适当的优化和调整。
实验二带优先级的时间片轮换的进程调度算法的实现
•
struct pcb *p;
•
for (i=0;i<MAXPIOR;i++)
•
{p=array[i];
•
while (p!=NULL)
•
{printf("id:%d,state:%d,pior:%d,life:%d\n",p->ident,p->state,p->pior,p->life);
•
p=p->next;
• {int i=0,ii=0;
• for (i=0;i<7;i++)
•
if (stricmp(str,command[i])==0)
•
break;
• switch(i)
•
{case 0:printf("thank you for using the program!\n");exit(0);
•
break;
•{
•
int i=MAXPIOR-1,pior=0,t;
•
struct pcb *pp,*qq,*pr,*r;
•
do
•
{
•
while (i>=0 && array[i]==NUf (i<0)
•
{
•
printf("NO process,please create it! \n");
第1个，再降低其优先级，插入到相应的队列中。 C）ps 查看当前进程状态 D）sleep 命令将进程挂起 E）awake 命令唤醒1个被挂起的进程 F）kill 命令杀死进程 G）quit命令退出 （4）选用面向对象的编程方法。
磁盘调度算法的模拟实现
磁盘调度算法的模拟实现磁盘调度算法是指操作系统中负责管理物理磁盘的一种算法，其主要目的是优化磁盘访问，提高磁盘效率。
常见的磁盘调度算法有FCFS（先来先服务）、SSTF（最短寻道时间优先）、SCAN（扫描）、C-SCAN（循环扫描）等。
下面我将分别介绍这几种算法的模拟实现。
1.FCFS（先来先服务）算法模拟实现：首先，我们需要定义一个队列，用于存储用户请求的磁道号。
然后，将用户请求的磁道号加入队列中，按照先来先服务的原则进行服务，即按照队列中的请求顺序依次访问磁盘。
计算总体访问时间等信息，并输出结果。
2.SSTF（最短寻道时间优先）算法模拟实现：首先，我们需要定义一个队列，用于存储用户请求的磁道号。
然后，从当前磁头位置开始，找到与当前位置距离最近的请求磁道号，计算距离最小的请求所在的队列位置，并将该请求从队列中取出访问磁盘。
重复上述过程，直至队列为空。
计算总体访问时间等信息，并输出结果。
3.SCAN（扫描）算法模拟实现：首先，我们需要定义一个队列，用于存储用户请求的磁道号。
然后，将用户请求的磁道号加入队列中，并将队列按磁道号从小到大排序。
假设当前磁头位置为start，将磁头移动到队列中第一个比start大的磁道号，然后按照顺时针方向继续移动，直至访问队列中最大的磁道号。
然后，改变移动方向，回到队列中最小的磁道号为止。
计算总体访问时间等信息，并输出结果。
4.C-SCAN（循环扫描）算法模拟实现：首先，我们需要定义一个队列，用于存储用户请求的磁道号。
然后，将用户请求的磁道号加入队列中，并将队列按磁道号从小到大排序。
假设当前磁头位置为start，将磁头移动到队列中第一个比start大的磁道号，然后按照顺时针方向继续移动，直至访问队列中最大的磁道号，并将磁头移动到队列中最小的磁道号。
计算总体访问时间等信息，并输出结果。
以上是对于不同磁盘调度算法的简要模拟实现。
在实际应用中，还需要考虑更多的细节，如怎样处理新到的请求、队列的管理等。
按优先级调度的算法
按优先级调度的算法优先级调度算法是一种调度算法，它根据任务的优先级来确定调度顺序。
每个任务都被赋予一个优先级值，优先级越高的任务越先被执行。
这种算法可用于各种任务调度场景，如操作系统进程调度、任务队列管理等。
在优先级调度算法中，每个任务都有一个优先级值，通常用一个整数表示。
较高的优先级值表示任务更紧急，需要更早被执行。
当多个任务同时就绪时，操作系统会选择优先级最高的任务先执行。
优先级调度算法的实现方式有多种，以下是几种常用的方法：1.静态优先级调度算法：每个任务在创建时就被赋予一个固定的优先级值，不会随着时间的推移而改变。
这种算法简单且实现成本低，但缺点是无法考虑任务的实时性需求。
2.动态优先级调度算法：根据任务的特点和运行状态动态调整任务的优先级值。
例如，可以根据任务的等待时间、执行时间、资源需求等因素进行评估和调整。
这种算法较为复杂，但可以更好地满足任务的实时性需求。
3.按时间片轮转调度：将任务按照优先级分组，每个优先级组分配一个时间片。
在每个时间片内，按照轮转方式依次执行每个任务。
当一个时间片用完后，如果组内还有未执行完的任务，则将未执行完的任务移到下一个优先级组，并分配一个新的时间片。
这种算法适用于多种任务需求的场景，可以实现任务的公平调度。
4.多级反馈队列调度：将任务按照优先级分组，并为每个优先级组分配一个时间片。
当一个时间片用完后，如果组内还有未执行完的任务，则将未执行完的任务移到下一个优先级组，并分配一个新的时间片。
同时，每个优先级组还可以根据任务执行情况进行动态优先级调整。
这种算法能够更好地平衡各个任务的执行时间和优先级。
总之，优先级调度算法是一种有效的任务调度方法，可以根据任务的优先级来确定执行顺序，从而改善系统的响应时间和资源利用率。
不同的实现方式适用于不同的任务需求，可以根据具体情况选择最合适的算法。
设计一个按优先数调度算法实现处理器调度的进程
设计一个按优先数调度算法实现处理器调度的进程
一．处理器调度的简介
处理器调度是指在若干作业并发处理时，对处理器分配工作的动态过程。
它是操作系统中的一种重要技术，其主要功能是控制并发作业的执行，使他们得到公平的分配，正确的完成执行，以达到有效利用处理机资源，
提高系统的工作效率。
处理器调度技术包括：处理机调度算法、处理机调
度技术等。
处理机调度算法就是基于计算机系统的工作机制，根据不同的作业在
处理机上的执行情况，系统在不同的阶段，根据量的不同，采用不同的算法，按优先级、分时等原则进行处理机调度，使作业在不同的阶段得到公
平的分配，以达到有效利用处理机资源，提高系统工作效率的目的。
按优先数调度算法( Priority Scheduling Algorithm )是指根据作
业的优先级先后来分配处理机资源，使作业能够按照优先级依次被处理，
使得系统性能有所提高。
1．处理器调度的算法流程
按优先数调度算法的处理器调度的过程，如下：
首先，从队列中取出一个作业，检查是否具有最高优先级，如果是，
则将其分配给处理机，否则，该作业放回队列，继续下一步判断；
其次，在没有作业可以处理时，处理机将停止运转。
调度算法C语言实现
调度算法C语言实现调度算法是操作系统中的重要内容之一，它决定了进程在系统中的运行方式和顺序。
本文将介绍两种常见的调度算法，先来先服务（FCFS）和最短作业优先（SJF），并用C语言实现它们。
一、先来先服务（FCFS）调度算法先来先服务（FCFS）调度算法是最简单的调度算法之一、它按照进程到达的先后顺序进行调度，即谁先到达就先执行。
实现这个算法的关键是记录进程到达的顺序和每个进程的执行时间。
下面是一个用C语言实现先来先服务调度算法的示例程序：```c#include <stdio.h>//进程控制块结构体typedef structint pid; // 进程IDint arrivalTime; // 到达时间int burstTime; // 执行时间} Process;int maiint n; // 进程数量printf("请输入进程数量：");scanf("%d", &n);//输入每个进程的到达时间和执行时间Process process[n];for (int i = 0; i < n; i++)printf("请输入进程 %d 的到达时间和执行时间：", i);scanf("%d%d", &process[i].arrivalTime,&process[i].burstTime);process[i].pid = i;}//根据到达时间排序进程for (int i = 0; i < n - 1; i++)for (int j = i + 1; j < n; j++)if (process[i].arrivalTime > process[j].arrivalTime) Process temp = process[i];process[i] = process[j];process[j] = temp;}}}//计算平均等待时间和平均周转时间float totalWaitingTime = 0; // 总等待时间float totalTurnaroundTime = 0; // 总周转时间int currentTime = 0; // 当前时间for (int i = 0; i < n; i++)if (currentTime < process[i].arrivalTime)currentTime = process[i].arrivalTime;}totalWaitingTime += currentTime - process[i].arrivalTime;totalTurnaroundTime += (currentTime + process[i].burstTime) - process[i].arrivalTime;currentTime += process[i].burstTime;}//输出结果float avgWaitingTime = totalWaitingTime / n;float avgTurnaroundTime = totalTurnaroundTime / n;printf("平均等待时间：%f\n", avgWaitingTime);printf("平均周转时间：%f\n", avgTurnaroundTime);return 0;```以上程序实现了先来先服务（FCFS）调度算法，首先根据进程的到达时间排序，然后依次执行每个进程，并计算总等待时间和总周转时间。
c语言实现进程调度算法
c语言实现进程调度算法进程调度算法是操作系统中的一个重要组成部分，用于决定在多道程序环境下，选择哪个进程来占用CPU并执行。
C语言是一种通用的编程语言，可以用于实现各种进程调度算法。
这里我将分别介绍三种常见的进程调度算法：先来先服务调度算法（FCFS）、最短作业优先调度算法（SJF）和轮转法调度算法（RR），并给出用C语言实现的示例代码。
首先，我们来看先来先服务调度算法（FCFS）。
此算法根据到达时间的先后顺序，按照先来后到的顺序进行处理。
下面是基于C语言的先来先服务调度算法实现示例代码：```c#include<stdio.h>struct Process};void FCFS(struct Process proc[], int n)for (int i = 1; i < n; i++)}printf("进程号到达时间服务时间完成时间等待时间周转时间\n");for (int i = 0; i < n; i++)}for (int i = 0; i < n; i++)}int maiint n;printf("请输入进程数：");scanf("%d", &n);struct Process proc[n];for (int i = 0; i < n; i++)printf("请输入进程%d的到达时间和服务时间（用空格分隔）：", i + 1);}FCFS(proc, n);return 0;```其次，我们来看最短作业优先调度算法（SJF），该算法选择执行时间最短的进程先执行。
下面是基于C语言的最短作业优先调度算法实现示例代码：```c#include<stdio.h>struct Process};void SJF(struct Process proc[], int n)for (int i = 0; i < n; i++)for (int j = 0; j < i; j++)}shortest_job = i;for (int j = i + 1; j < n; j++)shortest_job = j;}}}for (int i = 1; i < n; i++)}printf("进程号到达时间服务时间完成时间等待时间周转时间\n");for (int i = 0; i < n; i++)}for (int i = 0; i < n; i++)}int maiint n;printf("请输入进程数：");scanf("%d", &n);struct Process proc[n];for (int i = 0; i < n; i++)printf("请输入进程%d的到达时间和服务时间（用空格分隔）：", i + 1);}SJF(proc, n);return 0;```最后，我们来看轮转法调度算法（RR），该算法分配一个时间片给每个进程，当时间片用完后，将CPU分配给下一个进程。
wagner法
wagner法Wagner法，又称为Wagner-Whitin算法，是一种经典的生产调度算法。
该算法主要用于解决生产调度优化问题，可以帮助制定最优的生产计划和库存管理策略。
本文将从以下三个方面来介绍Wagner法：算法原理、应用场景以及优缺点。
一、算法原理Wagner法是一种动态规划算法。
该算法主要基于贝尔曼方程，通过计算在不同时间段的生产成本和库存成本，以确定最优的生产计划和库存策略。
在运用Wagner法时，首先需要确定各生产批次之间的时间间隔以及各批次的生产量。
然后，需要计算在每个时间段内所需的生产量和库存量，以及在每个时间段结束时的成本总和。
最后，在所有时间段结束时，可以得到最小的成本总和，这也就是Wagner算法的优化目标。
二、应用场景Wagner法常常被应用于生产调度和库存管理领域中。
对于一些需要经常性进行生产和补货的企业来说，使用Wagner法可以帮助他们合理规划生产和管理库存，并在最短的时间内实现成本最小化，提高企业的盈利能力。
此外，在一些物流或供应链管理中，Wagner法也可以用来优化运输成本。
通过合理规划货物的配送时间和运输量，可以最大限度地降低运输成本，优化供应链管理流程。
三、优缺点Wagner法的优点在于可以得到最优解以及实现成本最小化。
而且，该算法的计算比较简单，适用于不同规模的企业。
不过，Wagner法也存在一些缺点。
首先，对于许多复杂的生产调度问题而言，Wagner法可能无法找到最优解。
其次，它对于产品的需求和成本等参数有着相对较高的敏感度，在实际应用中可能需要进行多次的调整和优化。
总结Wagner法是一种经典的生产调度算法，其应用范围广泛，能够帮助企业实现成本最小化和库存管理优化。
尽管该算法存在一些缺点，但是在实际中仍然具有很高的应用价值。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
经典调度算法的实现学院：专业：姓名：学号：指导老师：2014-3-18目录一、课设简介 (3)1. 课程设计题目 (3)2. 课程设计目的 (3)3. 课程设计的内容 (3)4. 课程设计要求 (3)二、原理分析 (4)1. 先来先服务算法介绍与分析 (4)2. 短作业优先算法介绍与分析 (4)3. 高响应比优先调度算法介绍与分析 (4)4. 流程图 (5)三、主要功能模块 (7)1. 先来先服务算法实现代码 (7)2. 短作业优先算法实现代码 (8)3. 高响应比优先调度算法实现代码 (8)四、测试与运行结果 (9)1. 主界面 (9)2. 先来先服务算法测试 (10)3. 短作业优先算法测试 (11)4. 高响应比优先调度算法测试 (13)五、总结 (16)六、参考文献 (16)七、附录 (16)一、课设简介1.课程设计题目经典调度算法的实现2.课程设计目的操作系统课程设计是计算机专业重要的教学环节，它为学生提供了一个既动手又动脑，将课本上的理论知识和实际有机的结合起来，独立分析和解决实际问题的机会。
●进一步巩固和复习操作系统的基础知识。
●培养学生结构化程序、模块化程序设计的方法和能力。
●提高学生调试程序的技巧和软件设计的能力。
●提高学生分析问题、解决问题以及综合利用 C 语言进行程序设计的能力。
3.课程设计的内容实现以下几种调度算法1 FCFS2 SJF3 高响应比优先调度算法。
4.课程设计要求1．不同的功能使用不同的函数实现（模块化），对每个函数的功能和调用接口要注释清楚。
对程序其它部分也进行必要的注释。
2．对系统进行功能模块分析、画出总流程图和各模块流程图。
3．用户界面要求使用方便、简洁明了、美观大方、格式统一。
所有功能可以反复使用，最好使用菜单。
4．通过命令行相应选项能直接进入某个相应菜单选项的功能模块。
5．所有程序需调试通过。
二、原理分析1.先来先服务算法介绍与分析先来先服务调度算法是一种最简单的调度算法，该算法既可以用于作业调度，也可用于进程调度。
当在作业调度中采用该算法时，每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将他们调入内存，为它们分配资源、创建进程，然后放入就绪队列。
在进程调度中采用FCFS算法时，则每次调度是从就绪队列中选择一个最先进入该队列的进程，为之分配处理机，使之投入运行。
该进程一直运行到完成或发生某事件而阻塞后才放弃处理机。
FCFS算法比较有利于长作业（进程），而不利于短作业（进程）。
2.短作业优先算法介绍与分析短作业（进程）优先调度算法SJ（P）F，是指对短作业或短进程优先调度的算法。
它们可以分别用于作业调度和进程调度。
短作业优先（SJF）的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业，将它们调入内存运行。
而短进程（SPF）调度算法则是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机再重新调度。
SJ(P)F调度算法能有效地降低作业（进程）的平均等待时间，提高系统吞吐量。
该算法对长作业不利，完全未考虑作业的紧迫程度。
3.高响应比优先调度算法介绍与分析在批处理系统中，短作业优先算法是一种比较好的算法，其主要不足之处是长作业的运行得不到保证。
如果我们能为每个作业引人动态优先权，并使作业的优先级随着等待时间的增加而以速率a提高，则长作业在等待一定的时间后，必然有机会分配到处理机。
该优先权的变化规律可描述为:优先权=（等待时间+要求服务时间）/要求服务时间即优先权=响应时间/要求服务时间如果作业的等待时间相同，则要求服务的时间越短，其优先权越高，因而该算法有利于短作业。
当要求服务的时间相同时，作业的优先权决定于其等待时间，等待时间越长，优先权越高，因而它实现的是先来先服务对于长作业，作业的优先级可以随着等待时间的增加而提高，当其等待时间足够长时，其优先级便可以升到很高，从而也可获得处理机。
4.流程图图1、主函数流程图图2、先来先服务算法调度图3、短作业优先调度图4、高相应比算法调度三、主要功能模块1.先来先服务算法实现代码void sort() /* 建立对作业进行提交时间排列函数*/ {JCB *first, *second;int insert=0;if((jcb_ready==NULL)||((j->subtime)<(jcb_ready->subtime))) /*作业提交时间最短的,插入队首*/{j->link=jcb_ready;jcb_ready=j;T=j->subtime;j->Rp=1;}else /* 作业比较提交时间,插入适当的位置中*/{first=jcb_ready;second=first->link;while(second!=NULL){if((j->subtime)<(second->subtime)) /*若插入作业比当前作业提交时间短,*/{ /*插入到当前作业前面*/j->link=second;first->link=j;second=NULL;insert=1;}else /* 插入作业优先数最低,则插入到队尾*/ {first=first->link;second=second->link;}}if (insert==0) first->link=j;}}2.短作业优先算法实现代码void SJFget() /* 获取队列中的最短作业 */{JCB *front,*mintime,*rear;int ipmove=0;mintime=jcb_ready;rear=mintime->link;while(rear!=NULL)if((rear!=NULL)&&(T>=rear->subtime)&&(mintime->runtime)>(rear->runtim e)){front=mintime;mintime=rear;rear=rear->link;ipmove=1;}elserear=rear->link;if (ipmove==1){front->link=mintime->link;mintime->link=jcb_ready;}jcb_ready=mintime;}3.高响应比优先调度算法实现代码void HRNget() /* 获取队列中的最高响应作业 */{JCB *front,*mintime,*rear;int ipmove=0;mintime=jcb_ready;rear=mintime->link;while(rear!=NULL)if((rear!=NULL)&&(T>=rear->subtime)&&(mintime->Rp)<(rear->Rp)){front=mintime;mintime=rear;rear=rear->link;ipmove=1;}elserear=rear->link;if (ipmove==1){front->link=mintime->link; mintime->link=jcb_ready;}jcb_ready=mintime;}四、测试与运行结果1.主界面2.先来先服务算法测试3.短作业优先算法测试4.高响应比优先调度算法测试五、总结通过本次课程设计，更加深入的理解了先来先服务调度算法、短作业优先调度算法、高响应比优先调度算法的原理，及实现过程。
通过本次课设对这三种算法的优缺点有了进一步的理解。
进一步巩固和复习操作系统的基础知识，更进一步的了解了结构化模块化程序设计的方法，提高了调试程序的技巧。
同时在本次课设过程中，遇到了许多困难，通过请教同学，查询相关资料，及时解决了问题，但仍存在不足之处，将会在今后学习中更加努力。
六、参考文献1）宗大华，宗涛，陈吉人著操作系统北京：人民邮电出版社，20092）李爱华，程磊著面相对象程序设计（C++语言）北京: 清华大学出版社，20103）宋晓宇， windows操作系统核心编程实验教程中国铁道出版社4）张丽芬刘利雄王金玉编著操作系统实验教程清华大学出版社七、附录源代码#include <stdio.h>#include<conio.h>#include <stdlib.h>#define getpch(type) (type*)malloc(sizeof(type))struct worktime{float Tb; //作业运行时刻float Tc; //作业完成时刻float Ti; //周转时间float Wi; //带权周转时间};struct jcb { /*定义作业控制块JCB */char name[10]; //作业名float subtime; //作业提交时间float runtime; //作业所需的运行时间char resource; //所需资源float Rp; //后备作业响应比char state; //作业状态struct worktime wt;struct jcb* link; //链指针}*jcb_ready=NULL,*j;typedef struct jcb JCB;float T=0;void sort() /* 建立对作业进行提交时间排列函数*/{JCB *first, *second;int insert=0;if((jcb_ready==NULL)||((j->subtime)<(jcb_ready->subtime))) /*作业提交时间最短的,插入队首*/{j->link=jcb_ready;jcb_ready=j;T=j->subtime;//更改时间量j->Rp=1;}else /* 作业比较提交时间,插入适当的位置中*/{first=jcb_ready;second=first->link;while(second!=NULL){if((j->subtime)<(second->subtime)) /*若插入作业比当前作业提交时间短,*/{ /*插入到当前作业前面*/j->link=second;first->link=j;second=NULL;insert=1;}else /* 插入作业优先数最低,则插入到队尾*/{first=first->link;second=second->link;}}if (insert==0) first->link=j;}}void SJFget() /* 获取队列中的最短作业*/{JCB *front,*mintime,*rear;int ipmove=0;mintime=jcb_ready;//mintime指向作业对头rear=mintime->link;while(rear!=NULL)if((rear!=NULL)&&(T>=rear->subtime)&&(mintime->runtime)>(rear->runtime)) {//当插入作业到达时间要比时间量T小front=mintime;mintime=rear;//mintime指向rearrear=rear->link;ipmove=1;}elserear=rear->link;if (ipmove==1){front->link=mintime->link;mintime->link=jcb_ready;}jcb_ready=mintime;//把最终获取的min的需要时间赋给jcb_ready，开始执行}void HRNget() /* 获取队列中的最高响应作业*/{JCB *front,*mintime,*rear;int ipmove=0;mintime=jcb_ready;rear=mintime->link;while(rear!=NULL)if ((rear!=NULL)&&(T>=rear->subtime)&&(mintime->Rp)<(rear->Rp)){front=mintime;mintime=rear;rear=rear->link;ipmove=1;}elserear=rear->link;if (ipmove==1){front->link=mintime->link;mintime->link=jcb_ready;}jcb_ready=mintime;}void input() /* 建立作业控制块函数*/{ int i,num;printf("\n 请输入作业数:");scanf("%d",&num);for(i=0;i<num;i++){printf("\n 作业号No.%d:\n",i);j=getpch(JCB);printf("\n 输入作业名:");scanf("%s",j->name);printf("\n 输入作业提交时刻:");scanf("%f",&j->subtime);printf("\n 输入作业运行时间:");scanf("%f",&j->runtime);printf("\n");j->state='w';j->link=NULL;sort(); /* 调用sort函数*/}}int space()/*查看作业个数*/{int l=0; JCB* jr=jcb_ready;while(jr!=NULL){l++;jr=jr->link;}return(l);}void disp(JCB* jr,int select) /*建立作业显示函数,用于显示当前作业*/{if (select==3) printf("\n 作业服务时间响应比运行时刻完成时刻周转时间带权周转时间\n");else printf("\n 作业服务时间运行时刻完成时刻周转时间带权周转时间\n");printf(" %s\t",jr->name);printf(" %.2f\t ",jr->runtime);if (select==3) printf(" |%.2f ",jr->Rp);if (j==jr){printf(" %.2f\t",jr->wt.Tb);printf(" %.2f ",jr->wt.Tc);printf(" %.2f \t",jr->wt.Ti);printf(" %.2f",jr->wt.Wi);}printf("\n");}int destroy() /*建立作业撤消函数(作业运行结束,撤消作业)*/{printf("\n 作业[%s] 已完成.\n",j->name);free(j);return(1);}void check(int select) /* 建立作业查看函数*/{ JCB* jr;printf("\n **** 当前正在运行的作业是:%s",j->name); /*显示当前运行作业*/disp(j,select);jr=jcb_ready;printf("\n ****当前就绪队列状态为:\n"); /*显示就绪队列状态*/while(jr!=NULL){jr->Rp=(T-jr->subtime)/jr->runtime;disp(jr,select);jr=jr->link;}destroy();}void running(JCB* jr) /* 建立作业就绪函数(作业运行时间到,置就绪状态*/{if (T>=jr->subtime) jr->wt.Tb=T;//插入作业的到达时间比时间量小，T为该作业的开始时间else jr->wt.Tb=jr->subtime;//否则该作业到达时间为它的开始时间jr->wt.Tc=jr->wt.Tb+jr->runtime;jr->wt.Ti=jr->wt.Tc-jr->subtime;jr->wt.Wi=jr->wt.Ti/jr->runtime;T=jr->wt.Tc;}int main() /*主函数*/{A:int select=0,len,h=0;float sumTi=0,sumWi=0;printf("\t---*****************---\n"); printf("请选择作业调度算法的方式:\n");printf("\t1.FCFS 2.SJF 3.HRN 4.退出\n\n");printf("\t---*****************---\n");printf("请输入作业调度算法序号(1-4):");scanf("%d",&select);if (select==4){ exit(0);}else{input();len=space();while((len!=0)&&(jcb_ready!=NULL)){ h++;printf("\n 执行第%d个作业\n",h);j=jcb_ready;jcb_ready=j->link;j->link=NULL;j->state='R';running(j);sumTi+=j->wt.Ti;sumWi+=j->wt.Wi;check(select);if (select==2&&h<len-1) SJFget();if (select==3&&h<len-1) HRNget();printf("\n 按任一键继续......\n");getchar();getchar();}printf("\n\n 作业已经完成.\n");printf("\t 此组作业的平均周转时间：%.2f\n",sumTi/h); printf("\t 此组作业的带权平均周转时间：%.2f\n",sumWi/h); getchar();system("cls");}goto A;return(0);}。