操作系统实验六磁盘调度算法正确C代码

华南农业大学信息（软件）学院《操作系统分析与设讣实习》成绩单开设时间：2014学年笫一学期•程序设计水平优口良口中口差口语•程序运行效果及正确性优口良口中口差口•课程设计报告结构清晰优口良口中口差口•报告中总结和分析详尽优口良口中口差口教师签名111、需求分析：(1)输入的形式和输入值的范围：在文本框输入序列长度，输入值为int类型(2)输出的形式：输出每种磁盘调度算法的服务序列(3)程序所能达到的功能：模拟实现FCFS、SSTF、电梯LOOK、C-SCAN算法，并计算及比较磁头移动道数。

测试数据：包括正确的输入及其输出结果和含有错误的输入及其输出结果。

输入磁道范围(Tiooo输入所选磁道个数0^1000选择算法广42、概要设计:主程序流程图:3、详细设计：先来先服务算法（FCFS）:按先来后到次序服务，未作优化。

最简单的移臂调度算法是“先来先服务”调度算法，这个算法实际上不考虑访问者要求访问的物理位置，而只是考虑访问者提出访问请求的先后次序。

采用先来先服务算法决定等待访问者执行输入输出操作的次序时，移动臂来回地移动。

先来先服务算法花费的寻找时间较长，所以执行输入输出操作的总时间也很长。

最短寻道时间优先算法（SSTF）:最短寻找时间优先调度算法总是从等待访问者中挑选寻找时间最短的那个请求先执行的，而不管访问者到来的先后次序。

与先来先服务、算法比较，大幅度地减少了寻找时间，因而缩短了为各访问者请求服务的平均时间，也就提高了系统效率。

但最短查找时间优先（SSTF）调度，FCFS会引起读写头在盘面上的大范围移动，SSTF查找距离磁头最短（也就是查找时间最短）的请求作为下一次服务的对象。

SSTF查找模式有高度局部化的倾向，会推迟一些请求的服务，其至引起无限拖延（又称饥饿）。

扫描算法（SCAN）:SCAN算法乂称电梯调度算法。

SCAN算法是磁头前进方向上的最短查找时间优先算法，它排除了磁头在盘面局部位置上的往复移动，SCAN算法在很大程度上消除了SSTF 算法的不公平性，但仍有利于对中间磁道的请求。

操作系统磁盘调度算法实验报告及代码一、实验目的通过实验掌握磁盘调度算法的实现过程，了解各种不同磁盘调度算法的特点和优缺点，并比较它们的性能差异。

二、实验原理磁盘调度是操作系统中的重要内容，其主要目的是提高磁盘的利用率和系统的响应速度。

常见的磁盘调度算法有：FCFS（先来先服务）、SSTF （最短寻道时间）、SCAN（扫描）、C-SCAN（循环扫描）等。

三、实验过程1.编写代码实现磁盘调度算法首先，我们需要定义一个磁盘请求队列，其中存放所有的IO请求。

然后，根据所选的磁盘调度算法，实现对磁盘请求队列的处理和IO请求的调度。

最后，展示运行结果。

以FCFS算法为例，伪代码如下所示：```diskQueue = new DiskQueue(; // 创建磁盘请求队列while (!diskQueue.isEmpty()request = diskQueue.dequeue(; // 取出队列头的IO请求//处理IO请求displayResult(; // 展示运行结果```2.运行实验并记录数据为了验证各种磁盘调度算法的性能差异，我们可以模拟不同的场景，例如，随机生成一批磁盘IO请求，并使用不同的磁盘调度算法进行处理。

记录每种算法的平均响应时间、平均等待时间等指标。

3.撰写实验报告根据实验数据和结果，撰写实验报告。

实验报告通常包括以下内容：引言、实验目的、实验原理、实验步骤、实验结果、实验分析、结论等。

四、实验结果与分析使用不同的磁盘调度算法对磁盘IO请求进行处理，得到不同的实验结果。

通过对比这些结果，我们可以看出不同算法对磁盘IO性能的影响。

例如，FCFS算法对于请求队列中的请求没有排序，可能会导致一些请求等待时间过长。

而SSTF算法通过选择离当前磁道最近的请求进行处理，能够减少平均寻道时间，提高磁盘性能。

五、实验总结通过本次实验，我们学习了操作系统中磁盘调度算法的原理和实现过程。

不同的磁盘调度算法具有不同的优缺点，我们需要根据实际情况选择合适的算法。

操作系统进程调度C语言代码操作系统是计算机系统中的重要组成部分，用于管理和控制计算机资源的分配和使用。

在操作系统中，进程调度是指将系统资源（如 CPU、内存、磁盘、网络等）分配给运行中的进程的过程。

进程调度是操作系统实现多任务、多用户和分时系统的关键。

进程调度的算法有多种。

最常见的是时间片轮转算法、优先级调度算法、最短进程优先算法和先到先服务算法等。

下面我们将介绍一下时间片轮转算法的 C 语言代码实现。

1. 时间片轮转算法时间片轮转算法是一种基于时间片的调度算法，它给每个进程分配一个时间片，当时间片用完后，系统将进程暂停，并将 CPU 分配给下一个进程。

时间片轮转算法可以让所有进程公平地使用 CPU 时间，并且可以避免进程饥饿的情况发生。

2. C 语言代码实现在 C 语言中，可以用结构体来表示一个进程，包括进程 ID、进程状态、优先级、到达时间和需要运行的时间片等属性。

下面是一个简单的进程结构体的定义：```struct Process processes[5];在实现时间片轮转算法之前，需要先实现一个进程调度函数，它的作用是找到就绪进程中优先级最高的进程，并返回它的位置。

下面是一个简单的进程调度函数：```int find_highest_priority_process(struct Process *processes, int n) {int highest_priority = -1;int highest_priority_index = -1;for (int i = 0; i < n; i++) {if (processes[i].state != 2 && processes[i].priority >highest_priority) {highest_priority = processes[i].priority;highest_priority_index = i;}}return highest_priority_index;}```在实现时间片轮转算法之前，需要先定义一些全局变量，包括就绪队列、当前时间、时间片大小和进程数量等。

操作系统实验报告—磁盘调度算法操作系统实验报告实验3磁盘调度算法报告日期：20XX-6-17姓名：学号：班级：任课教师：实验3磁盘调度算法一、实验内容模拟电梯调度算法，实现对磁盘的驱动调度。

二、实验目的磁盘是一种高速、大量旋转型、可直接存取的存储设备。

它作为计算机系统的辅助存储器，负担着繁重的输入输出任务，在多道程序设计系统中，往往同时会有若干个要求访问磁盘的输入输出请示等待处理。

系统可采用一种策略，尽可能按最佳次序执行要求访问磁盘的诸输入输出请求，这就叫驱动调度，使用的算法称驱动调度算法。

驱动调度能降低为若干个输入输出请求服务所须的总时间，从而提高系统效率。

本实验要求学生模拟设计一个驱动调度程序，观察驱动调度程序的动态运行过程。

三、实验原理模拟电梯调度算法，对磁盘调度。

磁盘是要供多个进程共享的存储设备，但一个磁盘每个时刻只能为一个进程服务。

当有进程在访问某个磁盘时，其他想访问该磁盘的进程必须等待，直到磁盘一次工作结束。

当有多个进程提出输入输出请求处于等待状态，可用电梯调度算法从若干个等待访问者中选择一个进程，让它访问磁盘。

当存取臂仅需移到一个方向最远的所请求的柱面后,如果没有访问请求了,存取臂就改变方向。

假设磁盘有200个磁道，用C语言随机函数随机生成一个磁道请求序列放入模拟的磁盘请求队列中，假定当前磁头在100号磁道上，并向磁道号增加的方向上移动。

请给出按电梯调度算法进行磁盘调度时满足请求的次序,并计算出它们的平均寻道长度。

四、实验过程1.画出算法流程图。

2．源代码#include #include #include int *Init(intarr) {int i = 0;srand((unsignedint)time(0)); for (i = 0; i = num) {a[j+1] = arr[i]; j++; } else {b[k+1] = arr[i]; k++; } }printf(\访问序列：\\n\); for (i = 1; i 0; i--) { printf(\, b[i]); }sum = ((a[j]-100)*2+(100- b[1]))/15;printf(\平均寻道长度：%d\, sum); }int main {int arr[15] = { 0 }; int *ret=Init(arr); two_part(ret); getchar ; return 0;}4运行结果：五、实验小结通过本次实验，我对scan算法更加深入理解，用C语言模拟电梯调度算法，实现对磁盘的驱动调度，这个相比前两个实验实现起来相对简单，理解了算法实现起来尤为简单，程序敲出来之后没有错误，可直接运行，结果验证也无误。

操作系统实验报告——调度算法1. 实验目的本实验旨在探究操作系统中常用的调度算法，通过编写代码模拟不同的调度算法，了解它们的特点和应用场景。

2. 实验环境本次实验使用的操作系统环境为Linux，并采用C语言进行编码。

3. 实验内容3.1 调度算法1：先来先服务（FCFS）FCFS调度算法是一种简单且常见的调度算法。

该算法按照进程到达的先后顺序进行调度。

在本实验中，我们使用C语言编写代码模拟FCFS算法的调度过程，并记录每个进程的等待时间、周转时间和响应时间。

3.2 调度算法2：最短作业优先（SJF）SJF调度算法是一种非抢占式的调度算法，根据进程的执行时间来选择下一个要执行的进程。

在本实验中，我们使用C语言编写代码模拟SJF算法的调度过程，并计算每个进程的等待时间、周转时间和响应时间。

3.3 调度算法3：轮转调度（Round Robin）Round Robin调度算法是一种经典的时间片轮转算法，每个进程在给定的时间片内依次执行一定数量的时间。

如果进程的执行时间超过时间片，进程将被暂时挂起，等待下一次轮转。

在本实验中，我们使用C语言编写代码模拟Round Robin算法的调度过程，并计算每个进程的等待时间、周转时间和响应时间。

4. 实验结果分析通过对不同调度算法的模拟实验结果进行分析，可以得出以下结论：- FCFS算法适用于任务到达的先后顺序不重要的场景，但对于执行时间较长的进程可能会导致下一个进程需要等待较久。

- SJF算法适用于任务的执行时间差异较大的场景，能够提高整体执行效率。

- Round Robin算法适用于时间片相对较小的情况，能够公平地为每个进程提供执行时间。

5. 实验总结本次实验通过模拟不同调度算法的实际执行过程，深入了解了各种调度算法的原理、特点和适用场景。

通过对实验结果的分析，我们可以更好地选择合适的调度算法来满足实际应用的需求。

在后续的学习中，我们将进一步探索更多操作系统相关的实验和算法。

#include<stdio.h>#include<math.h>#include<stdlib.h>#define N 20typedef struct{int num;//磁道int flag;//1个标记量}V,*v;//********************************************************************* void Initial(v *a,int n){//初始化磁道请求printf("请输入请求顺序（磁道范围是0 - 199）:\n");for(int i = 1;i <= n;i++){a[i] = (v)malloc(sizeof(V));if(!a[i]) exit(-1);scanf("%d",&a[i]->num);a[i]->flag = 0;}}//*********************************************************************** void FCFS(v *a,int start,int n){//先到先服务算法int temp = start;float s = 0;printf("---------------------------FCFS调度算法----------------------------\n");for(int i = 1;i <= n; i++){temp = abs(a[i]->num - temp);s += temp;a[i]->flag = i;temp = a[i]->num;}int temp2;for(i = n;i >= 1;i--){//冒泡排序，按照磁道访问的先后顺序重新排列数组a,用于输出调度顺序for(int j = 1;j < i;j ++){if(a[j]->flag> a[j+1]->flag){temp = a[j]->flag;temp2 = a[j]->num;a[j]->flag = a[j+1]->flag;a[j]->num = a[j+1]->num;a[j+1]->flag = temp;a[j+1]->num = temp2;}}}printf("调度序列为：\n");printf("%d—>",start);for(i = 1;i <= n; i++){printf("%d —> ",a[i]->num);}printf("\n");printf("寻道长度是%f",s);printf("\n");printf("平均寻道长度是%f",s/n);printf("\n");printf("---------------------------FCFS调度算法----------------------------\n");}//************************************************************************ int Find(v *a,int n,int start){//找到离开始磁道最近的一项，返回下标int p;for(int i = 1;i < n;i++){if((a[i]->num <= start) && (start <=a[i+1]->num )){if(abs(a[i]->num - start) < abs(a[i+1]->num - start)){p = i;}else{p= i+1;}}}return p;}void SSTF(v *a,int start,int n){//最短寻道时间调度算法int temp;int pr,pl;//分别标记离磁头最近的那个磁道在数组中的下标的前一个和后一个float s = 0; //用来计算寻道长度temp = start;printf("---------------------------SSTF调度算法----------------------------\n");for(int i = n;i >= 1;i--){//冒泡排序,把磁道按由小到大的顺序排列for(int j = 1;j < i;j ++){if(a[j]->num > a[j+1]->num){temp = a[j]->num;a[j]->num = a[j+1]->num;a[j+1]->num = temp;}}}printf("排序后\n");for(int j=1;j<=n;j++)printf("%d ",a[j]->num);printf("\n");int p,x;p = Find(a,n,start);x = p;pr = p + 1;pl = p - 1;if(start <= a[1]->num){//磁头在最左边s =(float)(a[1]->num-start);printf("调度序列为：\n");printf("%d—>",start);for(i = 1;i <= n; i++){if(i!=1){s+=a[i]->num-a[i-1]->num;}printf("%d —> ",a[i]->num);}printf("\n");printf("寻道长度为%f",s);printf("\n");printf("平均寻道长度是%f",s/n);printf("\n");}else if(start >= a[n]->num){//磁头在最右边s =(float)(start-a[n]->num);printf("调度序列为：\n");printf("%d—>",start);for(i = n; i >= 1; i--){if(i!=1){s += a[i]->num-a[i-1]->num;}printf("%d —> ",a[i]->num);}printf("\n");printf("寻道长度为%f",s);printf("平均寻道长度是%f",s/n);printf("\n");}else{//磁头在中间printf("调度序列为：\n");printf("%d—>",start);printf("%d —> ",a[p]->num);s = (float)(a[p]->num - start);while(1){if(abs(a[pl]->num - a[p]->num) <= abs(a[p]->num - a[pr]->num)){s += a[p]->num-a[pl]->num;p = pl;printf("%d —> ",a[p]->num);pl--;if(pl==0){s += a[pr]->num-a[1]->num;s += a[n]->num-a[pr]->num;for(int i=pr;i<=n;i++){printf(" %d—>",a[i]->num);}break;}}else{s += a[pr]->num-a[p]->num;p = pr;printf("%d —> ",a[p]->num);pr++;if(pr==n+1){s += a[n]->num-a[pl]->num;s += a[pl]->num-a[1]->num;for(int i=pl;i>=1;i--){printf("%d —> ",a[i]->num);}break;}}}printf("\n");printf("寻道长度为%f",s);printf("\n");printf("平均寻道长度是%f",s/n);printf("\n");}printf("---------------------------SSTF调度算法----------------------------\n");}//********************************************************************** void SCAN(v *a,int start,int n){//电梯算法int l = 0 ;//用于设置访问磁道的flagint temp,temp2;for(int i = n;i >= 1;i--){//冒泡排序,把磁道按由小到大的顺序排列for(int j = 1;j < i;j ++){if(a[j]->num > a[j+1]->num){temp = a[j]->num;a[j]->num = a[j+1]->num;a[j+1]->num = temp;}}}int p,x;p = Find(a,n,start);x = p;float s = 0;int toleft,toright;printf("---------------------------SCAN调度算法----------------------------\n"); if(abs(start - a[1]->num) < abs(a[n]->num - start))toleft = 1;//磁头离最左端的磁道近elsetoright = 1;//磁头离最右端的磁道近temp = start;if(toleft == 1){//先向0磁道方向访问while(p != 0){temp = abs(a[p]->num - temp);s += temp;l += 1;temp = a[p]->num;a[p]->flag = l;p--;}s += a[1]->num - 0;temp = 0;x = x + 1;while(x != n){temp = abs(a[x]->num - temp);s += temp;l += 1;temp = a[x]->num;a[x]->flag =l;x++;}for(i = n;i >= 1;i--){//冒泡排序，按照访问的顺序将数组重新排列for(int j = 1;j < i;j ++){if(a[j]->flag> a[j+1]->flag){temp = a[j]->flag;temp2 = a[j]->num;a[j]->flag = a[j+1]->flag;a[j]->num = a[j+1]->num;a[j+1]->flag = temp;a[j+1]->num = temp2;}}}printf("调度序列为：\n");printf("%d—>",start);for(i = 1;i <= n; i++){printf("%d —> ",a[i]->num);}printf("\n");printf("寻道长度是%f",s);printf("\n");printf("平均寻道长度是%f",s/n);printf("\n");}if(toright == 1){//先向199磁道方向访问while(p != n+1){temp = abs(a[p]->num - temp);s += temp;l += 1;temp = a[p]->num;a[p]->flag = l;p++;}s += abs(199 - a[n]->num);temp = 199;x = x - 1;while(x != 0){temp = abs(a[x]->num - temp);s += temp;l += 1;temp = a[x]->num;a[x]->flag =l;x--;}for(i = n;i >= 1;i--){//冒泡排序,按照访问的顺序将数组重新排列for(int j = 1;j < i;j ++){if(a[j]->flag> a[j+1]->flag){temp = a[j]->flag;temp2 = a[j]->num;a[j]->flag = a[j+1]->flag;a[j]->num = a[j+1]->num;a[j+1]->flag = temp;a[j+1]->num = temp;}}}printf("调度序列为：\n");printf("%d—>",start);for(i = 1;i <= n; i++){printf("%d —> ",a[i]->num);}printf("\n");printf("寻道长度是%f",s);printf("\n");printf("平均寻道长度是%f",s/n);printf("\n");}printf("---------------------------SCAN调度算法----------------------------\n");}//*************************************************************************void CSCAN(v *a,int start,int n){//int temp,temp2;int l = 0;for(int i = n;i >= 1;i--){//冒泡排序for(int j = 1;j < i;j ++){if(a[j]->num > a[j+1]->num){temp = a[j]->num;a[j]->num = a[j+1]->num;a[j+1]->num = temp;}}}int p,x;p = Find(a,n,start);x = p;float s = 0;temp = start;printf("---------------------------CSCAN调度算法----------------------------\n"); if((n - p) >= p ){//右边的磁道数比左边的磁道数多while(p != n+1){temp = abs(a[p]->num - temp);s += temp;l += 1;temp = a[p]->num;a[p]->flag = l;p++;}s += abs(199 - a[n]->num);temp = 0;x = x + 1;i = 1;while(i != x){temp = abs(a[i]->num - temp);s += temp;l += 1;temp = a[i]->num;a[i]->flag = l;i++;}for(i = n;i >= 1;i--){//冒泡排序,按照访问的顺序将数组重新排列for(int j = 1;j < i;j ++){if(a[j]->flag> a[j+1]->flag){temp = a[j]->flag;temp2 = a[j]->num;a[j]->flag = a[j+1]->flag;a[j]->num = a[j+1]->num;a[j+1]->flag = temp;a[j+1]->num = temp2;}}}printf("调度序列为：\n");printf("%d—>",start);for(i = 1;i <= n; i++){printf("%d —> ",a[i]->num);}printf("\n");printf("寻道长度是%f",s);printf("\n");printf("平均寻道长度是%f",s/n);printf("\n");}else{//左边的磁道数比右边的磁道数多while(p != 0){temp = abs(a[p]->num - temp);s += temp;l += 1;temp = a[p]->num;a[p]->flag = l;p--;}s += a[1]->num - 0;temp = 199;i = n;while(i != x){temp = abs(a[i]->num - temp);s += temp;temp = a[i]->num;l += 1;a[i]->flag =l;i--;}for(i = n;i >= 1;i--){//冒泡排序,按照访问的顺序将数组重新排列for(int j = 1;j < i;j ++){if(a[j]->flag> a[j+1]->flag){temp = a[j]->flag;temp2 = a[j]->num;a[j]->flag = a[j+1]->flag;a[j]->num = a[j+1]->num;a[j+1]->flag = temp;a[j+1]->num = temp2;}}}printf("调度序列为：\n");printf("%d—>",start);for(i = 1;i <= n; i++){printf("%d —> ",a[i]->num);}printf("\n");printf("寻道长度是%f",s);printf("\n");printf("平均寻道长度是%f",s/n);printf("\n");}printf("---------------------------CSCAN调度算法----------------------------\n");}//************************************************************************** void main(){int n;//v a[N];int start;//磁头开始的位置int choice;//用于标记操作的序号printf("******************************磁盘调度算法****************************\n");printf(" ");printf("1.FCFS调度算法\n");printf(" ");printf("2.SSTF调度算法\n");printf(" ");printf("3.SCAN调度算法\n");printf(" ");printf("4.CSCAN调度算法\n");printf(" ");printf("5.退出\n");printf("******************************磁盘调度算法****************************\n");printf("请输入请求的柱面数:");scanf("%d",&n);printf("请输入磁头开始的位置:");scanf("%d",&start);Initial(a,n);while(1){printf("请选择你要的操作序号\n");scanf("%d",&choice);switch(choice){case 1:FCFS(a,start,n);break;case 2:SSTF(a,start,n);break;case 3:SCAN(a,start,n);break;case 4:CSCAN(a,start,n);break;case 5:exit(-1);default:printf("你输入的操作序号有误！");}printf("\n");}}。

// 磁ä?盘¨¬调Ì¡Â度¨¨.cpp : 定¡§义©?控?制?台¬¡§应®|用®?程¨¬序¨©的Ì?入¨?口¨²点Ì?。

¡ê//#include"stdafx.h"#include"iostream"usingnamespace std;#define maxsize 100void PrintArray(intarray[],int m){for(int i=0;i<m;i++){cout<<array[i]<<" ";}}//FCFSvoid FCFS(intarray[],int m){int sum=0,j,i;PrintArray(array,m);for(i=0,j=1;j<m;i++,j++){sum+=abs(array[j]-array[i]);}cout<<"移©?动¡¥的Ì?总Á¨¹道̨¤数ºy：êo"<<sum<<endl;}//SSTFvoid SSTF(intarray[],int m){int k=0;int now,l,r;int i,j,sum=0;BubbleSort(array,m);PrintArray(array,m);cout<<"请?输º?入¨?当Ì¡À前¡ã磁ä?道̨¤号?：êo";cin>>now;if(array[m-1]<=now)//当Ì¡À前¡ã磁ä?道̨¤位?于®¨²最Á?后¨®一©?个?的Ì?后¨®面?{for(i=m-1;i>=0;i--){cout<<array[i]<<" ";}sum=now-array[0];}elseif(array[0]>=now)//当Ì¡À前¡ã磁ä?道̨¤位?于®¨²第̨²一©?个?之?前¡ã{for(i=0;i<m;i++){cout<<array[i]<<" ";}sum=array[m-1]-now;}else//当Ì¡À前¡ã磁ä?道̨¤位?于®¨²中D间?位?置?{while(array[k]<now)//寻¡ã找¨©当Ì¡À前¡ã磁ä?道̨¤的Ì?位?置?{k++;}l=k-1;r=k;while((l>=0)&&(r<m))//确¨¡¤定¡§磁ä?头ª¡¤移©?动¡¥方¤?向¨© {if((now-array[l])<=(array[r]-now)){cout<<array[l]<<" ";sum+=now-array[l];now=array[l];l=l-1;}else{cout<<array[r]<<" ";sum+=array[r]-now;now=array[r];r=r+1;}}if(l==-1){for(j=r;j<m;j++){cout<<array[j]<<" ";}sum+=(array[m-1]-array[0]);}if(r==m){for(j=l;j>=0;j--)cout<<array[j]<<" ";sum+=(array[m-1]-array[0]);}}cout<<"移©?动¡¥的Ì?总Á¨¹道̨¤数ºy：êo"<<sum<<endl;}//SCANvoid SCAN(intarray[],int m){int k=1;int now,l,r,d;int i,j,sum=0;BubbleSort(array,m);PrintArray(array,m);cout<<"请?输º?入¨?当Ì¡À前¡ã磁ä?道̨¤号?：êo";cin>>now;if(array[m-1]<=now){for(i=m-1;i>=0;i--)cout<<array[i]<<" ";sum=now-array[0];}elseif(array[0]>=now){for(i=0;i<m;i++)cout<<array[i]<<" ";sum=array[m-1]-now;}else{while(array[k]<now){k++;}l=k-1;r=k;cout<<"请?输º?入¨?当Ì¡À前¡ã移©?动¡¥臂À?移©?动¡¥的Ì?方¤?向¨©（ꡧ1表À¨ª示º?向¨©内¨²，ê?0表À¨ª示º?向¨©外ªa）ê?：êo";cin>>d;if(d==0){for(j=l;j>=0;j--){cout<<array[j]<<" ";}for(j=r;j<m;j++){cout<<array[j]<<" ";}sum=now-2*array[0]+array[m-1];}else{for(j=r;j<m;j++){cout<<array[j]<<" ";}for(j=1;j>=0;j--){cout<<array[j]<<" ";}sum=-now-array[0]+2*array[m-1];}}cout<<"移©?动¡¥的Ì?总Á¨¹道̨¤数ºy：êo"<<sum<<endl;}void main(){int c;FILE *fp;int cidao[maxsize];int i=0,count;fp=fopen("E:/VC//cidao.txt","r+");if(fp==NULL){cout<<"文?件t打䨩不?开a！ê?"<<endl;exit(0);}while(!feof(fp)){if((fgetc(fp))==-1){printf("请?输º?入¨?磁ä?道̨¤的Ì?个?数ºy:");cin>>count;for(i=0;i<count;i++){printf("请?输º?入¨?磁ä?道̨¤%d的Ì?磁ä?道̨¤号?:",i+1);cin>>cidao[i];}}else{fscanf(fp,"%d",&cidao[i]);i++;}}count=i;for(i=0;i<count;i++){printf("%5d",cidao[i]);}cout<<endl;while(1){cout<<endl<<"系¦Ì统ª3菜?单Ì£¤如¨?下?：êo"<<endl;printf("1.FCFS 2.SSTF 3.SCAN");cout<<endl;printf("4.EXIT");cout<<endl;cout<<"请?选?择?：êo";cin>>c;if(c>3)break;switch(c){case 1:FCFS(cidao,count);break;case 2:SSTF(cidao,count);break;case 3:SCAN(cidao,count);break;}}}。

#include<stdlib.h>#include<iostream.h>#include<cmath>typedef struct node{int data;struct node *next;}Node;void main(){void fcfs(Node *,int,int);//声明先来先服务函数FCFSvoid sstf(Node *,int,int);//声明最短寻道时间优先函数SSTFvoid scan(Node *,int,int);//声明扫描函数SC ANvoid print(Node *); //输出链表函数Node *head,*p,*q; //建立一个链表int it,c=0,f,s; //c为链表长度,f是开始的磁道号,s是选择哪个算法head=(Node *)malloc(sizeof(Node));head->next=NULL;q=head;cout<<" /**************磁盘调度算法***************/"<<endl;cout<<endl;cout<<"新建一个单链表,以0作为结束标志:";cin>>it;while(it!=0){p=(Node*)malloc(sizeof(Node));p->next=NULL;p->data=it;q->next=p;q=p;cin>>it;c++;}cout<<"从几号磁道开始:";cin>>f;print(head);cout<<"链表长度为:"<<c<<endl;cout<<"1、先来先服务算法FCFS"<<endl;cout<<"2、最短寻道时间优先算法SSTF"<<endl;cout<<"3、电梯调度算法(扫描算法SC AN)"<<endl;cout<<"0、退出"<<endl;cout<<"请选择:";cin>>s;while(s!=0){switch(s){case 1:cout<<"你选择了:先来先服务算法FCFS"<<endl;fcfs( head,c,f);break;case 2:cout<<"你选择了:最短寻道时间优先算法SSTF"<<endl;sstf( head,c,f);break;case 3:cout<<"你选择了:电梯调度算法(扫描算法SC AN)"<<endl;scan( head,c,f);break;}cout<<"退出请选0,继续请选1,2,3:";cin>>s;}}/***********************************************************/void fcfs(Node *head,int c,int f)//先来先服务算法{void print(Node *);Node *l;//*m,*n;float num=0;l=head->next;for(int i=0;i<c;i++){num+=abs(l->data-f);f=l->data;l=l->next;}num=num/c;cout<<"先来先服务的寻道顺序是:"<<endl;print(head);cout<<"平均寻道长度:"<<num<<endl;}/*****************************************************************/ void sstf(Node *head,int c,int f){void print(Node *);Node *p,*q,*r,*s,*l,*m;l=(Node *)malloc(sizeof(Node));l->next=NULL;m=l;q=head;p=head->next;s=head;r=head->next;float num=0;for(int i=0;i<c;i++){int min=abs(f-r->data);for(int j=0;j<c-i-1;j++){p=p->next;q=q->next;if(abs(f-p->data)<min){min=abs(f-p->data);r=p;s=q;}}num+=abs(f-r->data);f=r->data;s->next=r->next;r->next=NULL;m->next=r;m=r;q=head;p=head->next;s=head;r=head->next;}num=num/c;cout<<"最短寻道时间优先顺序是:"<<endl;print(l);cout<<"平均寻道长度:"<<num<<endl;}/***************************************************************/ void scan(Node *head,int c,int f)//扫描算法（电梯调度算法）{void print(Node *);int min,max,i=0,j=0;float num=0;Node *p,*q,*r,*s,*m,*n,*x,*y;r=(Node *)malloc(sizeof(Node));//存放比开始磁道小的磁道r->next=NULL;s=r;m=(Node *)malloc(sizeof(Node));//存放比开始磁道大的磁道m->next=NULL;n=m;x=(Node *)malloc(sizeof(Node));x->next=NULL;y=x;q=head;p=head->next;while(p->next!=NULL){if(p->data-f>0){q->next=p->next;p->next=NULL;n->next=p;n=p;p=q->next;i++;}else{q->next=p->next;p->next=NULL;s->next=p;s=p;p=q->next;j++;}}if(p->data>=f){n->next=p;n=p;i++;}else{s->next=p;s=p;j++;}q=r; //对比开始磁道小的磁道排序p=r->next;while(q->next->next!=NULL){q=q->next;p=q->next;max=q->data;while(p->next!=NULL){if(p->data>max){max=p->data;p->data=q->data;q->data=max;max=q->data;}p=p->next;}if(p->data>max){max=p->data;p->data=q->data;q->data=max;max=q->data;}}//print(r);q=m;p=m->next;while(q->next->next!=NULL){q=q->next;p=q->next;min=q->data;while(p->next!=NULL){if(p->data<min){min=p->data;p->data=q->data;q->data=min;min=q->data;}p=p->next;}if(p->data<min){min=p->data;p->data=q->data;q->data=min;min=q->data;}}//print(m);x=m;p->next=r->next;y=x->next;while(y->next!=NULL){num+=abs(f-y->data);f=y->data;y=y->next;}num+=abs(f-y->data);num=num/c;cout<<"扫描算法的顺序是:"<<endl;print(x);cout<<"平均寻道长度为:"<<num<<endl;}/*****************************************************/ void print(Node *head) //输出链表{Node *p;p=head->next;cout<<"单链表显示:";if(p==NULL){cout<<"单链表为空:";}else if(p->next==NULL){cout<<p->data;}else{while(p->next!=NULL){cout<<p->data<<"->";p=p->next;}cout<<p->data<<endl;}}。

操作系统实验：首先在文件目录下建立hard.txt C++源代码：#include<stdio.h>#include<iostream.h>#include<string.h>#include<math.h>//读入磁道号流const int MAXQUEUE=200;typedef struct node{int go;int visited;}qu;qu queue[MAXQUEUE];int quantity;int start;void initial(){int i;for(i=0;i<MAXQUEUE;i++){queue[i].go=-1;queue[i].visited=0;}start=53;//磁头的初始位置}void readData(){FILE *fp;char fname[20];int temp,i;cout<<"请输入磁道号流文件名:"; strcpy(fname,"hard.txt");cin>>fname;if((fp=fopen(fname,"r"))==NULL){cout<<"错误,文件打不开,请检查文件名:)"<<endl;}else{while(!feof(fp)){fscanf(fp,"%d ",&temp);queue[quantity].go=temp;quantity++;}cout<<endl<<"---------------------------------------------"<<endl; cout<<"所读入的磁道号流:";for(i=0;i<quantity;i++){cout<<queue[i].go<<" ";}cout<<endl<<"请求数为:"<<quantity<<endl;}}//FIFO算法void FIFO(){int i;int total=0;int current;cout<<endl<<"---------------------------------------------"<<endl; cout<<"FIFO算法的访问磁道号顺序流:";current=start;for(i=0;i<quantity;i++){cout<<queue[i].go<<" ";total+=abs(queue[i].go-current);current=queue[i].go;}cout<<endl<<"磁头移过的柱面数:"<<total;}//最短寻道优先调度算法void shortest(){int i,j,p;int total=0;int current;cout<<endl<<"---------------------------------------------"<<endl;cout<<"最短寻道优先调度算法的访问磁道号顺序流:";current=start;for(i=0;i<quantity;i++){p=0;while(queue[p].visited!=0){p++;}for(j=p;j<quantity;j++){if((queue[j].visited==0)&&(abs(current-queue[p].go)>abs(current-queue[j].go))){ p=j;}}cout<<queue[p].go<<" ";total+=abs(queue[p].go-current);queue[p].visited=1;current=queue[p].go;}cout<<endl<<"磁头移过的柱面数:"<<total;}//电梯算法void elevator(){int i,j,p,flag;int total=0;int current;cout<<endl<<"---------------------------------------------"<<endl;cout<<"电梯调度算法"<<endl;//磁头初始向里cout<<"磁头初始向里的访问磁道号顺序流:";current=start;for(i=0;i<quantity;i++){flag=1000;p=-1;for(j=0;j<quantity;j++){if((queue[j].visited==0)&&(queue[j].go>=current)){if(abs(queue[j].go-current)<flag){p=j;flag=abs(queue[j].go-current);}}}if(p!=-1){cout<<queue[p].go<<" ";total+=abs(queue[p].go-current);current=queue[p].go;queue[p].visited=1;}else{for(j=0;j<quantity;j++){if((queue[j].visited==0)&&(queue[j].go<current)){ if(abs(queue[j].go-current)<flag){p=j;flag=abs(queue[j].go-current);}}}cout<<queue[p].go<<" ";total+=abs(queue[p].go-current);current=queue[p].go;queue[p].visited=1;}}cout<<endl<<"磁头移过的柱面数:"<<total<<endl;//磁头初始向外for(i=0;i<quantity;i++){queue[i].visited=0;}total=0;cout<<"磁头初始向外的访问磁道号顺序流:";current=start;for(i=0;i<quantity;i++){flag=1000;p=-1;for(j=0;j<quantity;j++){if((queue[j].visited==0)&&(queue[j].go<=current)){ if(abs(queue[j].go-current)<flag){p=j;flag=abs(queue[j].go-current);}}if(p!=-1){cout<<queue[p].go<<" ";total+=abs(queue[p].go-current);current=queue[p].go;queue[p].visited=1;}else{for(j=0;j<quantity;j++){if((queue[j].visited==0)&&(queue[j].go>current)){if(abs(queue[j].go-current)<flag){p=j;flag=abs(queue[j].go-current);}}}cout<<queue[p].go<<" ";total+=abs(queue[p].go-current);current=queue[p].go;queue[p].visited=1;}}cout<<endl<<"磁头移过的柱面数:"<<total;}//显示版权信息函数void version(){cout<<endl<<endl;cout<<" ┏━━━━━━━━━━━━━━━━━━━━━━━┓"<<endl; cout<<" ┃磁盘调度算法系统┃"<<endl;cout<<" ┠───────────────────────┨"<<endl; cout<<" ┃(c)All Right Reserved Neo┃"<<endl;cout<<" ┃sony006@┃"<<endl; cout<<" ┃version 2004 build 1122┃"<<endl;cout<<" ┗━━━━━━━━━━━━━━━━━━━━━━━┛"<<endl;cout<<endl<<endl;}void main(){int i;version();initial();readData();FIFO();shortest();for(i=0;i<quantity;i++){ queue[i].visited=0;}elevator();}。

C语言磁盘调度算法1.FCFS（先来先服务）算法：FCFS算法按照磁盘请求的顺序进行调度，即按照先来先服务的原则，先处理先到达磁盘的请求。

它的实现非常简单，只需要按照请求的顺序进行访问即可。

C代码示例：```c#include <stdio.h>#include <stdlib.h>int fcfs(int start, int *requests, int n)int i;int total = abs(start - requests[0]);for (i = 1; i < n; i++)total += abs(requests[i] - requests[i - 1]);}return total;int maiint start = 50;int requests[] = { 82,170, 43, 140, 24, 16, 190};int n = sizeof(requests) / sizeof(requests[0]);int total = fcfs(start, requests, n);printf("Total head movement: %d\n", total);return 0;```2.SSTF（最短寻道时间优先）算法：SSTF算法每次都选择离当前磁道最近的请求进行处理，以减少寻道时间。

具体实现时，需要计算每个请求到当前磁道的距离，并选择最小的距离进行处理。

C代码示例：```c#include <stdio.h>#include <stdlib.h>int sstf(int start, int *requests, int n)int i, j;int total = 0;int visited[n];for (i = 0; i < n; i++)visited[i] = 0;}int cur = start;for (i = 0; i < n; i++)int minDist = __INT_MAX__;int index = -1;for (j = 0; j < n; j++)if (!visited[j])int dist = abs(cur - requests[j]); if (dist < minDist)minDist = dist;index = j;}}}total += minDist;visited[index] = 1;cur = requests[index];}return total;int maiint start = 50;int requests[] = { 82,170, 43, 140, 24, 16, 190};int n = sizeof(requests) / sizeof(requests[0]);int total = sstf(start, requests, n);printf("Total head movement: %d\n", total);return 0;```3.SCAN（电梯算法）算法：SCAN算法模拟电梯的运行方式，先向一个方向扫描直到末尾，然后再改变方向向另一个方向扫描，以此往复。

C语言磁盘调度算法
一、磁盘调度算法
磁盘调度算法是指在磁盘读写期间，将磁头移动的方式。

磁盘调度算法是操作系统和磁盘控制器的重要部分，它决定了磁头移动的顺序，最后影响磁盘读写的速度和效率。

先来先服务算法是一种比较基础的磁盘调度算法，它根据任务的先后顺序，按照FIFO(First-In-First-Out)的原则，先处理先提交的任务，后提交的任务后处理。

这种算法简单易实现，而且给出的结果是最长的寻道时间，但是其在分布较为不均匀的情况下容易导致较长的寻道时间。

2、最短寻道时间优先(Shortest Seek Time First，SSTF)
最短寻道时间优先算法是最新的一种磁盘调度算法，它把磁头移动的次数和磁头移动时间两个因素考虑在内，每次把最短寻道时间的任务优先处理，从而尽量减少磁头移动的次数，减少磁头的停顿次数，提高磁盘读写效率。

3、扫描算法(SCAN)
扫描算法称作电梯调度算法，也称作时钟调度算法，原理是先从其中一侧开始扫描。

操作系统实验磁盘调度算法实验报告一.实验目的本实验旨在通过磁盘调度算法的模拟，探究不同调度算法对磁盘访问性能的影响，了解各种算法的特点和适用场景。

二.实验方法本实验通过编写磁盘调度模拟程序，实现了三种常见的磁盘调度算法：FCFS（先来先服务）、SSTF（最短寻找时间优先）和SCAN（扫描算法）。

实验中使用C语言编程语言，并通过随机生成的队列模拟磁盘访问请求序列。

三.实验过程1.FCFS（先来先服务）算法FCFS算法是一种非常简单的调度算法，它按照请求到达的顺序进行调度。

在实验中，我们按照生成的请求队列顺序进行磁盘调度，记录每次磁头移动的距离。

2.SSTF（最短寻找时间优先）算法SSTF算法是一种动态选择离当前磁头位置最近的磁道进行调度的算法。

在实验中，我们根据当前磁头位置和请求队列中的磁道位置，选择距离最近的磁道进行调度。

然后将该磁道从请求队列中移除，并记录磁头移动的距离。

3.SCAN（扫描算法）算法SCAN算法是一种按照一个方向进行扫描的算法，它在每个方向上按照磁道号的顺序进行调度，直到扫描到最边缘磁道再折返。

在实验中，我们模拟磁头从一个端点开始，按照磁道号从小到大的顺序进行调度，然后再折返。

记录磁头移动的距离。

四.实验结果与分析我们通过生成不同数量的请求队列进行实验，记录每种算法的磁头移动距离，并进行比较。

实验结果显示，当请求队列长度较小时，FCFS算法的磁头移动距离较短，因为它按照请求到达的顺序进行调度，无需寻找最短的磁道。

然而，当请求队列长度较大时，FCFS算法的磁头移动距离会显著增加，因为它不能根据距离进行调度。

SSTF算法相对于FCFS算法在磁头移动距离上有了明显改进。

SSTF算法通过选择最短的寻找时间来决定下一个访问的磁道，因此可以减少磁头的移动距离。

然而，在请求队列中存在少量分散的请求时，SSTF算法可能会产生扇区的服务死锁现象，导致一些磁道无法及时访问。

SCAN算法通过扫描整个磁盘来进行调度，有效解决了FCFS算法有可能导致的服务死锁问题。