先来先服务和短作业优先的代码实现

先来先服务和优先数调度算法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. 算法原理优先数调度算法是一种非抢占式的进程调度算法。

先来先服务，短作业优先，⾼响应⽐进程调度算法的实现⼀、实验内容编程实现先来先服务算法、短作业优先算法、⾼响应⽐算法，并求出每个作业的完成时间、周转时间、带权周转时间，及平均周转时间、平均带权周转时间。

⼆、实验要求1.任选⼀种⾼级语⾔实现；2.选择FCFS、SJF、HRRN调度算法；3.能够输⼊进程的基本信息，如进程名、提交时间、预估运⾏时间等；4.根据选择的调度算法显⽰进程调度顺序；5.显⽰完成调度后每个进程的开始时间、完成时间呢、周转时间，带权周转时间；6.计算平均周转时间和平均带权周转时间；三、实验过程1、设计思想FCFS算法对提交时间进⾏排序，按提交时间从⼩到⼤的顺序调度，SJF算法从第⼆个进程开始计算找出当前处在就绪等待队列的进程，并找出其中运⾏时间最短的作为下次调度的进程，HRRN算法从第⼆个进程开始计算找出当前处在就绪等待队列的进程，并找出其中响应⽐最⼩的作为下次调度的进程2.运⾏结果四、实验代码#include<iostream>#include<Windows.h>#include<stdio.h>#include<stdlib.h>#include <time.h>#define N 5using namespace std;struct Mystruct{float arrivetime;float runtime;float starttime;float waittime;float endtime;float turnaroundtime;float rightturnaroundtime;}Thread[N];void sort(struct Mystruct Thread[]) {//按进程到达时间排序for (int i = 0; i < N; i++) {for (int j = 0; j < N - 1; j++) {if (Thread[j].arrivetime > Thread[j + 1].arrivetime) {float t1 = Thread[j + 1].arrivetime;Thread[j + 1].arrivetime = Thread[j].arrivetime;Thread[j].arrivetime = t1;float t2 = Thread[j + 1].runtime;Thread[j + 1].runtime = Thread[j].runtime;Thread[j].runtime = t2;}}}}float JRR(float i, float j, float k) {//计算响应⽐float s = (i - j + k) / k;//cout << i << " " << j << " " << k << "响应⽐" << s << endl;return s;}void RRsort(int i) {//找出最⼩响应⽐进程的下标与下次要运⾏的进程交换次序，使处在就绪状态响应⽐最⼩的进程下次运⾏int next = 0;float min = 30;for (int j = i + 1; j < N; j++){if (Thread[j].arrivetime <= Thread[i].endtime) {float RR;// cout << Thread[i].endtime << endl;if (i != 4)RR = JRR(Thread[i].endtime, Thread[j].arrivetime, Thread[j].runtime);if (RR < min)//找出最⼩响应⽐{min = RR;next = j;}}}Mystruct temp;temp = Thread[i + 1];Thread[i + 1] = Thread[next];Thread[next] = temp;}void FCFS() {int count = 0;cout << "==========================先来先服务算法调度==========================" << endl;sort(Thread);float avewaittime = 0,aveturnaroundtime=0,averightturnaroundtime=0;cout << "作业号" << "\t" << "提交时间" << "\t" << "运⾏时间" << "\t" << "开始时间" << "\t" << "等待时间" << "\t" << "完成时间"<<"\t" << "周转时间" << " \t" << "带权周转时间" << endl;for (int i = 0; i < N; i++){count++;if (count == 1)Thread[i].starttime = Thread[i].arrivetime; else Thread[i].starttime=Thread[i-1].starttime+Thread[i-1].runtime;if (Thread[i].starttime<Thread[i].arrivetime){Thread[i].starttime = Thread[i].arrivetime;}Thread[i].endtime = Thread[i].starttime + Thread[i].runtime;Thread[i].waittime = Thread[i].starttime - Thread[i].arrivetime;Thread[i].turnaroundtime = Thread[i].endtime - Thread[i].arrivetime;Thread[i].rightturnaroundtime = Thread[i].turnaroundtime / Thread[i].runtime;avewaittime += Thread[i].waittime; aveturnaroundtime += Thread[i].turnaroundtime; averightturnaroundtime += Thread[i].rightturnaroundtime;cout <<count<<"\t" <<Thread[i].arrivetime << "\t\t" << Thread[i].runtime << "\t\t" << Thread[i].starttime << "\t\t" << Thread[i].waittime << "\t\t" << Thr ead[i].endtime << "\t\t" << Thread[i].turnaroundtime << "\t\t" << Thread[i].rightturnaroundtime << endl;}cout << "平均等待时间：" << avewaittime / N << "\t" << "平均周转时间：" << aveturnaroundtime/N << "\t" << "平均带权周转时间：" << averightturna roundtime / N << endl;}void SJF(struct Mystruct Thread[]){float avewaittime = 0, aveturnaroundtime = 0, averightturnaroundtime = 0;for (int m = 0; m < N - 1; m++){if (m == 0)Thread[m].endtime = Thread[m].arrivetime + Thread[m].runtime;else{if (Thread[m - 1].endtime >= Thread[m].arrivetime){Thread[m].starttime = Thread[m - 1].endtime;}else{Thread[m].starttime = Thread[m].arrivetime;}Thread[m].endtime = Thread[m].starttime + Thread[m].runtime;}int i = 0;for (int n = m + 1; n <= N - 1; n++){if (Thread[n].arrivetime <= Thread[m].endtime)i++;}//按运⾏时间排序float min = Thread[m + 1].runtime;int next = m + 1;//m+1=nfor (int k = m + 1; k < m + i; k++){if (Thread[k + 1].runtime < min){min = Thread[k + 1].runtime;next = k + 1;}}// cout << min << endl;Mystruct temp;temp = Thread[m + 1];Thread[m + 1] = Thread[next];Thread[next] = temp;}int count = 0;cout << "==========================短作业优先算法调度==========================" << endl;cout << "作业号" << "\t" << "提交时间" << "\t" << "运⾏时间" << "\t" << "开始时间" << "\t" << "等待时间" << "\t" << "完成时间" << "\t" << "周转时间" << " \t" << "带权周转时间" << endl;for (int i = 0; i < N; i++){count++;if (count == 1){Thread[i].starttime = Thread[i].arrivetime;Thread[i].endtime = Thread[i].starttime + Thread[i].runtime;Thread[i].waittime = Thread[i].starttime - Thread[i].arrivetime;Thread[i].turnaroundtime = Thread[i].endtime - Thread[i].arrivetime;Thread[i].rightturnaroundtime = Thread[i].turnaroundtime / Thread[i].runtime;cout << count << "\t" << Thread[i].arrivetime << "\t\t" << Thread[i].runtime << "\t\t" << Thread[i].starttime << "\t\t" << Thread[i].waittime << "\t\t" << Thread[i].endtime << "\t\t" << Thread[i].turnaroundtime << "\t\t" << Thread[i].rightturnaroundtime << endl;}else{Thread[i].starttime = Thread[i - 1].starttime + Thread[i - 1].runtime;if (Thread[i].starttime < Thread[i].arrivetime){Thread[i].starttime = Thread[i].arrivetime;}Thread[i].endtime = Thread[i].starttime + Thread[i].runtime;Thread[i].waittime = Thread[i].starttime - Thread[i].arrivetime;Thread[i].turnaroundtime = Thread[i].endtime - Thread[i].arrivetime;Thread[i].rightturnaroundtime = Thread[i].turnaroundtime / Thread[i].runtime;avewaittime += Thread[i].waittime; aveturnaroundtime += Thread[i].turnaroundtime; averightturnaroundtime += Thread[i].rightturnaroundtime;cout << count << "\t" << Thread[i].arrivetime << "\t\t" << Thread[i].runtime << "\t\t" << Thread[i].starttime << "\t\t" << Thread[i].waittime << "\t\t" << Thread[i].endtime << "\t\t" << Thread[i].turnaroundtime << "\t\t" << Thread[i].rightturnaroundtime << endl;}}cout << "平均等待时间：" << avewaittime / N << "\t" << "平均周转时间：" << aveturnaroundtime / N << "\t" << "平均带权周转时间：" << averightturn aroundtime / N << endl;}void HRRN(struct Mystruct Thread[]){int count = 0;float avewaittime = 0, aveturnaroundtime = 0, averightturnaroundtime = 0;cout << "==========================⾼响应⽐算法调度==========================" << endl;cout << "作业号" << "\t" << "提交时间" << "\t" << "运⾏时间" << "\t" << "开始时间" << "\t" << "等待时间" << "\t" << "完成时间" << "\t" << "周转时间" << "\t" << "带权周转时间" << endl;for (int i = 0; i < N; i++){count++;if (count == 1)Thread[i].starttime = Thread[i].arrivetime; else Thread[i].starttime = Thread[i - 1].starttime + Thread[i - 1].runtime;if (Thread[i].starttime < Thread[i].arrivetime){Thread[i].starttime = Thread[i].arrivetime;}Thread[i].endtime = Thread[i].starttime + Thread[i].runtime;RRsort(i);//找出处在等待的最⼩响应⽐的进程下次运⾏Thread[i].waittime = Thread[i].starttime - Thread[i].arrivetime;Thread[i].turnaroundtime = Thread[i].endtime - Thread[i].arrivetime;Thread[i].rightturnaroundtime = Thread[i].turnaroundtime / Thread[i].runtime;avewaittime += Thread[i].waittime; aveturnaroundtime += Thread[i].turnaroundtime; averightturnaroundtime += Thread[i].rightturnaroundtime;cout << count << "\t" << Thread[i].arrivetime << "\t\t" << Thread[i].runtime << "\t\t" << Thread[i].starttime << "\t\t" << Thread[i].waittime << "\t\t" << T hread[i].endtime << "\t\t" << Thread[i].turnaroundtime << "\t\t" << Thread[i].rightturnaroundtime << endl;}cout << "平均等待时间：" << avewaittime / N << "\t" << "平均周转时间：" << aveturnaroundtime / N << "\t" << "平均带权周转时间：" << averightturn aroundtime / N << endl;}int main() {srand((int)time(0));for (int i = 0; i < N; i++) {Thread[i].arrivetime = rand() % 20;Thread[i].runtime = rand() % 20 + 1;}FCFS();SJF(Thread);HRRN(Thread);return 0;}五、实验总结通过本次实验我更加了解了先来先服务算法、短作业优先算法、⾼响应⽐算法，通过带权周转时间的计算知道了FCFS算法对长作业有利，对短作业不利，SJF算法对短作业有利，对长作业不利，在所有进程同时可运⾏是采⽤SJF算法的平均等待时间、平均周转时间最少。

2024年研究生考试考研计算机学科专业基础(408)复习试题(答案在后面)一、单项选择题（本大题有40小题，每小题2分，共80分）1、下列关于冯·诺依曼体系结构的叙述中，正确的是：A. 计算机由运算器、控制器、存储器、输入设备和输出设备五大部件组成。

B. 指令和数据存放在不同的存储器中。

C. 冯·诺依曼体系结构的计算机硬件系统分为运算器、显示器和键盘三大部分。

D. 程序指令存储在内存中，但数据不能存储在内存中。

2、在计算机内部，数据通常采用哪种形式表示？A. 十进制B. 八进制C. 十六进制D. 二进制3、CPU可以直接访问的存储器是哪一个？A. 软盘B. 硬盘C. 内存D. 光盘4、在计算机网络中，以下哪项不是TCP/IP模型的层次结构之一？A. 网络接口层B. 网络层C. 应用层D. 物理层5、以下哪个算法是用于查找非平衡二叉搜索树中某个特定节点的最坏情况时间复杂度？A. 二分查找B. 中序遍历C. 平衡二叉搜索树查找D. 二叉树遍历6、以下哪个语言是用于实现编译原理的？A. JavaB. C++C. PythonD. Haskell7、在计算机系统中，地址总线的宽度决定了CPU可以直接寻址的内存空间大小。

如果某计算机系统的地址总线宽度为32位，则该CPU的最大直接寻址空间为：A. 4GBB. 8GBC. 16GBD. 32GB8、在数据结构中，队列是一种特殊的线性表，其特点是先进先出（FIFO）。

若在一个初始为空的队列中按照顺序插入元素A、B、C、D，然后执行两次删除操作，再插入元素E、F，接着再次执行两次删除操作，此时队列的队首元素是：A. AB. BC. CD. F9、在关系数据库中，两个表之间的连接是一种生成新表的操作，它将第一个表中的行与第二个表中的行匹配。

如果连接操作没有找到匹配项，则返回NULL。

假设我们有两个表：Table1(A, B)，Table2(C, D)，其中A与C是连接字段。

作业调度算法之短作业优先调度算法和先来先服务调度算法假设有四个作业，他们的提交、运⾏时间如下表所⽰。

请回答下列问题：
（1）若采⽤短作业优先调度算法，求作业运⾏顺序和平均带权周转时间为多少？
（2）若采⽤先来先服务调度算法，求作业运⾏顺序和平均带权周转时间为多少？
作业号到达时间运⾏时间
18.0 2.0
28.30.5
38.50.4
48.70.1
解：
（1）短作业优先调度算法，作业运⾏顺序：4,3,2,1
（2）先来先服务调度算法，作业运⾏顺序：1,2,3,4
作业号1234
到达时间8.08.38.58.7
运⾏时间 2.00.50.40.1
短作业优先调度算法
完成时刻11.79.79.28.8周转时间 3.7 1.40.70.1带权周转时间 1.85 1.751平均带全周转时间 1.85
先来先服务调度算法
完成时刻1010.510.911周转时间2 2.2 2.4 2.3带权周转时间1 4.4623平均带全周转时间8.6
注：周转时间= 完成时刻—到达时刻带权周转时间= 周转时间/运⾏时间。

进程调度算法代码进程调度算法是操作系统中的一种重要机制，它决定了在多道程序环境下，如何安排各个进程的执行顺序和时间片。

不同的进程调度算法有不同的实现方式和优缺点，本文将就常见的几种进程调度算法进行详细介绍。

1. 先来先服务（FCFS）先来先服务是最简单、最直观的进程调度算法。

它按照进程到达时间的先后顺序进行调度，即先到达的进程先执行。

当一个进程开始执行后，直到该进程执行完毕或者发生某些阻塞事件才会切换到另一个进程。

FCFS算法代码如下：```void FCFS(){int i;for(i=0;i<n;i++){run(p[i].need_time);if(i!=n-1){wait(p[i+1].arrive_time-p[i].arrive_time-p[i].need_time); }}}```其中，p数组表示所有需要执行的进程，n表示总共有多少个需要执行的进程。

run函数表示运行该进程所需时间片，wait函数表示等待下一个进程到达所需时间。

FCFS算法优点是简单易懂、公平性好，但其缺点也很明显：无法处理短作业优先问题、平均等待时间长等。

2. 短作业优先（SJF）短作业优先是一种非抢占式的进程调度算法，它根据每个进程的执行时间来进行排序，执行时间短的进程先执行。

如果有多个进程的执行时间相同，则按照到达时间的先后顺序进行调度。

SJF算法代码如下：```void SJF(){int i,j;for(i=0;i<n;i++){for(j=i+1;j<n;j++){if(p[i].need_time>p[j].need_time){swap(p[i],p[j]);}}}for(i=0;i<n;i++){run(p[i].need_time);if(i!=n-1){wait(p[i+1].arrive_time-p[i].arrive_time-p[i].need_time); }}}```其中，swap函数表示交换两个进程的位置。

调度算法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）调度算法，首先根据进程的到达时间排序，然后依次执行每个进程，并计算总等待时间和总周转时间。

计算机操作系统实验报告实验二进程调度算法一、实验名称：进程调度算法二、实验内容：编程实现如下算法：1.先来先服务算法；2.短进程优先算法；3.时间片轮转调度算法。

三、问题分析与设计：1.先来先服务调度算法先来先服务调度算法是一种最简单的调度算法，该算法既可以用于作业调度，也可用于进程调度。

当在作业调度中采用该算法时，每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将他们调入内存，为它们分配资源、创建进程，然后放入就绪队列。

在进程调度中采用FCFS算法时，则每次调度是从就绪队列中选择一个最先进入该队列的进程，为之分配处理机，使之投入运行。

该进程一直运行到完成或发生某事件而阻塞后才放弃处理机。

FCFS算法比较有利于长作业（进程），2.短作业（进程）优先调度算法短作业（进程）优先调度算法SJ（P）F，是指对短作业或短进程优先调度的算法。

它们可以分别用于作业调度和进程调度。

短作业优先（SJF）的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业，将它们调入内存运行。

而短进程（SPF）调度算法则是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机再重新调度。

SJ(P)F调度算法能有效地降低作业（进程）的平均等待时间，提高系统吞吐量。

该算法对长作业不利，完全未考虑作业的紧迫程度。

3.时间片轮转算法在时间片轮转算法中，系统将所有的就绪进程按先来先服务的原则排成一个队列，每次调度时，把CPU分配给队首进程，并令其执行一个时间片。

当执行的时间片用完时，由一个计数器发出时钟中断请求，调度程序便据此信号来停止该进程的执行，并将它送往就绪队列的末尾；然后，再把处理机分配给就绪队列中新的队首进程，同时也让它执行一个时间片。

这样就可以保证就绪队列中的所有进程在一给定的时间内均能获得一时间片的处理机执行时间。

换言之，系统能在给定的时间内响应所有用户的请求。

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

2、需求分析(1) 输入的形式和输入值的范围输入值：进程个数Num 范围：0<Num<=100依次输入Num个进程的到达时刻范围：依次输入Num个进程的服务时刻范围：输入要使用的算法（1-FCFS，2-SJF）范围：1或者2(2) 输出的形式（X表示变量）时刻X：进程X开始运行。

其完成时刻：X 周转时刻：X 带权周转时刻：X…（省略（Num-1）个）平均周转时刻：X平均带权周转时刻：X(3) 程序所能达到的功能输入进程个数Num，每个进程到达时刻ArrivalTime[i]，服务时刻ServiceTime[i]。

采纳先来先服务FCFS或者短作业优先SJF进程调度算法进行调度，计算每个进程的完成时刻、周转时刻和带权周转时刻，同时统计Num个进程的平均周转时刻和平均带权周转时刻。

3、概要设计讲明本程序中用到的所有抽象数据类型的定义、主程序的流程以及各程序模块之间的层次(调用)关系。

4、详细设计5、调试分析(1)调试过程中遇到的问题以及解决方法，设计与实现的回忆讨论和分析○1开始的时候没有推断进程是否到达，导致短进程优先算法运行结果错误，后来加上了推断语句后就解决了改问题。

○2差不多完成的设计所要实现的功能，总的来讲，FCFS编写容易，SJF需要先找到差不多到达的进程，再从差不多到达的进程里找到进程服务时刻最短的进程，再进行计算。

(2)算法的改进设想改进：即使用户输入的进程到达时刻没有先后顺序也能准确的计算出结果。

（确实是再加个循环，推断各个进程的到达时刻先后，组成一个有序的序列）(3)经验和体会通过本次实验，深入理解了先来先服务和短进程优先进程调度算法的思想，培养了自己的动手能力，通过实践加深了经历。

6、用户使用讲明（1）输入进程个数Num（2）依次输入Num个进程的到达时刻（3）依次输入Num个进程的服务时刻（4）选择要使用的算法7、测试结果正确一（FCFS）：正确一（SJF）：正确二（FCFS）：正确二（SJF）：错误（进程个数错误）：错误（选择算法错误）：8、附录//***************************************************** **************//** 进程调度算法 BY：09软件工程二班李群**//***************************************************** **************#include<iostream>#include<iomanip>using namespace std;static const int Max=100;int ArrivalTime[Max];//到达时刻int ServiceTime[Max];//服务时刻int FinishTime[Max];//完成时刻int WholeTime[Max];//周转时刻double WeightWholeTime[Max];//帯权周庄时刻double AverageWT_FCFS,AverageWT_SJF; //平均周转时刻double AverageWWT_FCFS,AverageWWT_SJF;//平均帯权周转时刻int ServiceTime_SJF[Max];//在SJF算法中使用到int Num=0;int NowTime=0;//记录当前时刻double SumWT=0,SumWWT=0;//SumWT用来计算总的周转时刻，SumWWT用来计算总的帯权周转时刻int i;int choice;//记录选择//***************************************************** *************// 先到先服务算法//***************************************************** *************void FCFS()//找最早到达的。

先来先服务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() //找最早到达的。

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分配给下一个进程。