磁盘调度算法的模拟实现
磁盘调度算法的模拟实现及对比

磁盘调度算法的模拟实现及对比磁盘调度算法是操作系统中的一个重要组成部分,用于优化磁盘读写操作的效率,提高系统的响应速度和运行效率。
常见的磁盘调度算法包括先来先服务(FCFS)算法、最短寻道时间优先(SSTF)算法、电梯(Elevator)算法等。
在进行磁盘调度算法的比较和模拟之前,我们首先需要了解磁盘读写操作的基本原理。
磁盘是由许多磁道和扇区组成的,当操作系统需要对磁盘进行读写操作时,读写头需要按照特定的路径移动到目标扇区,这个过程称为寻道。
而磁头在寻道的过程中所花费的时间称为寻道时间。
不同的磁盘调度算法的主要目标就是使得寻道时间尽可能地短,从而提高磁盘的读写操作效率。
首先,我们来实现一个先来先服务(FCFS)算法的模拟。
FCFS算法是最简单的磁盘调度算法,它按照磁盘请求的先后顺序进行处理。
具体实现如下:```pythondef fcfs(disk_queue, start):head_movement = 0curr_pos = startfor request in disk_queue:head_movement += abs(request - curr_pos)curr_pos = requestreturn head_movement```上述代码中,`disk_queue`表示磁盘请求队列,`start`表示起始磁道号。
算法首先将磁头移动到起始磁道号`start`,然后按照磁盘请求的先后顺序对队列中的请求进行处理,计算磁头的移动距离。
最后返回磁头的总移动距离。
接下来,我们实现一个最短寻道时间优先(SSTF)算法的模拟。
SSTF 算法会选择离当前磁道最近的请求进行处理,从而减少磁头的寻道时间。
具体实现如下:```pythondef sstf(disk_queue, start):head_movement = 0curr_pos = startwhile disk_queue:min_distance = float('inf')min_index = -1for i, request in enumerate(disk_queue):distance = abs(request - curr_pos)if distance < min_distance:min_distance = distancemin_index = ihead_movement += min_distancecurr_pos = disk_queue.pop(min_index)return head_movement```上述代码中,算法首先将磁头移动到起始磁道号`start`,然后不断选择离当前磁道最近的请求处理,直到所有请求处理完毕。
磁盘调度试验

实验四磁盘调度实验目的编程模拟实现磁盘调度的常用算法或调试分析相关磁盘调度程序, 加深对磁盘调度常用算法的理解和实现技巧。
实验内容1.自定义磁盘调度相关的数据结构;2.依据先来先服务算法(FCFS)、最短寻道优先算法(SSTF)、扫描(SCAN, 也称电梯)算法的原理, 编写对应函数, 模拟系统的磁盘调度服务;3.为了更好地模拟和评价算法的性能, 随机产生需寻道的磁道序列, 以磁道序列的首磁道为磁头的当前位置;在SCAN算法中, 允许用户指定当前寻道方向;4.统计以上算法总寻道次数和平均寻道距离;比较/分析以上算法的寻道性能, 并做出自己的评价。
实验步骤(源程序)#include<stdio.h>#include<stdlib.h>#include<iostream.h>#include<math.h>#define maxsize 1000int decide(char str[]) //判断输入数据是否有效{int i=0;while(str[i]!='\0'){if(str[i]<'0'||str[i]>'9'){return 0;break;}i++;}return i;}int trans(char str[], int a) //将字符串转换成数字{int i;int sum=0;for(i=0;i<a;i++){sum=sum+(int)((str[i]-'0')*pow(10,a-i-1));}return sum;}int *bubble(int cidao[],int m){int i,j;int temp;for(i=0;i<m;i++) //使用冒泡法按从小到大顺序排列 for(j=i+1;j<m;j++){if(cidao[i]>cidao[j]){temp=cidao[i];cidao[i]=cidao[j];cidao[j]=temp;}}cout<<"排序后的磁盘序列为: ";for( i=0;i<m;i++) //输出排序结果 {cout<<cidao[i]<<" ";}cout<<endl;return cidao;} int printnow(){char str[10];int a,now;cout<<"请输入当前的磁道号: ";A: cin>>str;a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入! "<<endl;goto A;}elsenow=trans(str,a);return now;}int printout(int cidao[],int now,int m)int i;int sum=0;cout<<"磁盘扫描序列为: ";for(i=m-1;i>=0;i--){cout<<cidao[i]<<" ";sum+=abs(now-cidao[i]);now=cidao[i];}return sum;}int printin(int cidao[],int now,int m){int i;int sum=0;cout<<"磁盘扫描序列为: ";for(i=0;i<m;i++){cout<<cidao[i]<<" ";sum+=abs(cidao[m-1]-now);now=cidao[i];}return sum;}int prints(int cidao[],int now,int m,int l,int r) {int j;int sum=0;while(l>=0){cout<<cidao[l]<<" ";sum+=now-cidao[l];now=cidao[l];l=l-1;}now=cidao[0];for(j=r;j<m;j++){cout<<cidao[j]<<" ";sum+=cidao[j]-now;now=cidao[j];}return sum;int printl(int cidao[],int now,int m,int l,int r){int j;int sum=0;while(r<m){cout<<cidao[r]<<" ";sum+=cidao[r]-now;now=cidao[r];r=r+1;}now=cidao[m-1];for(j=l;j>=0;j--){cout<<cidao[j]<<" "; //输出磁盘调度序列sum+=now-cidao[j];now=cidao[j];}return sum;}void FCFS(int cidao[],int m) //磁道号数组, 个数为m {int now;float sum=0; //总寻道长度 int j,i;float ave;cout<<"磁盘请求序列为: ";for( i=0;i<m;i++) //按先来先服务的策略输出磁盘请求序列 {cout<<cidao[i]<<" ";}cout<<endl;now=printnow(); //输入当前磁道号cout<<"磁盘扫描序列为: ";for( i=0;i<m;i++) //输出磁盘扫描序列{cout<<cidao[i]<<" ";}for(i=0,j=1;j<m;i++,j++) //求平均寻道长度{sum+=abs(cidao[j]-cidao[i]);ave=(float)(sum)/(float)(m);}cout<<endl;cout<<"平均寻道长度: "<<ave<<endl;}void SSTF(int cidao[],int m){int k=1;int now,l,r;int sum;float ave;cidao=bubble(cidao,m); //调用冒泡排序算法排序now=printnow(); //输入当前磁道号if(cidao[m-1]<=now) //若当前磁道号大于请求序列中最大者, sum=printout(cidao,now,m);if(cidao[0]>=now) //若当前磁道号小于请求序列中最小者, sum=printin(cidao,now,m);if(now>cidao[0]&&now<cidao[m-1]) //若当前磁道号大于请求序列中最小者且小于最大者{cout<<"磁盘扫描序列为: ";while(cidao[k]<now) //确定当前磁道在已排的序列中的位置, 后面的算法都用到了, 可以直接复制后少量修改, 节省时间。
磁盘调度算法的模拟实现

磁盘调度算法的模拟实现学院专业学号学生姓名指导教师姓名2014年3月19日目录一、课设简介 (2)1.1 课程设计题目 (2)1.2 课程设计目的 (2)1.3 课程设计要求 (2)二、设计内容 (3)2.1功能实现 (3)2.2流程图 (3)2.3具体内容 (3)三、测试数据 (4)3.3 测试用例及运行结果 (4)四、源代码 (5)五、总结 (12)5.1 总结............................................一、课设简介1.1课程设计题目磁盘调度算法的模拟实现11.2程序设计目的操作系统课程设计是计算机专业重要的教学环节,它为学生提供了一个既动手又动脑,将课本上的理论知识和实际有机的结合起来,独立分析和解决实际问题的机会。
1)进一步巩固和复习操作系统的基础知识。
2)培养学生结构化程序、模块化程序设计的方法和能力。
3)提高学生调试程序的技巧和软件设计的能力。
4)提高学生分析问题、解决问题以及综合利用C语言进行程序设计的能力。
1.3 设计要求1)磁头初始磁道号,序列长度,磁道号序列等数据可从键盘输入,也可从文件读入。
2)最好能实现磁道号序列中磁道号的动态增加。
3)磁道访问序列以链表的形式存储4)给出各磁盘调度算法的调度顺序和平均寻道长度二、设计内容2.1 功能实现设计并实现一个本别利用下列磁盘调度算法进行磁盘调度的模拟程序。
1) 先来先服务算法FCFS 2) 最短寻道时间优先算法SSTF 2.2流程图2.3具体内容1)先来先服务算法FCFS这是一种比较简单的磁盘调度算法。
它根据进程请求访问磁盘的先后次序进行调度。
此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。
此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情开始 选择算法 F C F S S S T F 结束况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。
操作系统实验报告—磁盘调度算法

操作系统实验报告—磁盘调度算法操作系统实验报告实验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语言模拟电梯调度算法,实现对磁盘的驱动调度,这个相比前两个实验实现起来相对简单,理解了算法实现起来尤为简单,程序敲出来之后没有错误,可直接运行,结果验证也无误。
编程模拟实现磁盘调度算法.doc

编程模拟实现磁盘调度算法(1)—采用最短寻道时间优先算法班级04师本(3)班学号0408008301 姓名陈海颖一、实验目的与实验项目介绍1、实验目的通过实际编程来模拟实现磁盘调度算法中的采用最短寻道时间优先算法,并达到对知识的熟练掌握。
2、实验项目介绍本设计为磁盘调度算法模拟实现系统,选用Microsoft Visual 2005中的作为开发工具,实现最短寻道时间优先算法.二、实验项目方案设计1、算法思想:最短寻道时间优先算法:首先确定当前磁头所在的磁道号,然后对请求的磁道号从小到大进行排序。
接着找到一个跟当前磁道号最接近的磁道号;如找到则从当前位置开始执行,接着从当前磁道号再找一个跟当前磁道号最接近的磁道号,依次执行,直到结束。
2、算法流程先把输入的要求访问的序列号从小到大排序,分析当前位置的可能位置。
如果当前位置小于最小序列号,则不做改动,直接按顺序输出;如果当前位置大于最大的序列号,则将序列从大到小排序,再按顺序输出即可;如果不是这两种情况,则将当前位置虚拟插入序列号中,比较当前位置左右的序列号与当前位置的距离,找出距离最小的并将其值赋给OUTPUT和当前位置,再从新的当前位置寻找下一个最短距离的序列号。
如此循环,即可实现最短寻道时间优先算法。
三、实验实施步骤1、创建应用程序界面在VB.NE中使用WINDOWS应用程序生成一个窗体应用程序form1,并给主窗口取名为“模拟磁盘调度算法之最短寻道时间优先算法”。
2、窗体设计如下图所示;建立界面(如上图),包含17个文本框,分别表示当前磁头位置、即将访问的队列(5个)、算法得到的序列(5个)、每次移动距离和移动总距离。
4个按钮控件Button1—Button3激活各个算法,Button1实现清除算法,使各控件初始为零,重新运算;Button2实现调度算法,Button3实现平均移动距离的算法,Label实现总移动距离的求解。
3、具体控件的功能及如何实现(1)输入的要求访问的序列号的表示如图所示,用TextBox1、TextBox2、TextBox3、 TextBox4、TextBox5存放输入的5个系列号,TextBox6存放输入的当前位置nowpoint,通过下面的代码,将各文本框的值用变量m1、 m2 、m3、 m4、m5、nowpoint:m1 = Val(TextBox1.Text)m2 = Val(TextBox2.Text)m3 = Val(TextBox3.Text)m4 = Val(TextBox4.Text)m5 = Val(TextBox5.Text)nowpoint = Val(TextBox6.Text)(2)按钮“执行算法”,单击该按钮即实现最短寻道时间优先算法。
磁盘调度算法的模拟实现

磁盘调度算法的模拟实现磁盘调度算法是指操作系统中负责管理物理磁盘的一种算法,其主要目的是优化磁盘访问,提高磁盘效率。
常见的磁盘调度算法有FCFS(先来先服务)、SSTF(最短寻道时间优先)、SCAN(扫描)、C-SCAN(循环扫描)等。
下面我将分别介绍这几种算法的模拟实现。
1.FCFS(先来先服务)算法模拟实现:首先,我们需要定义一个队列,用于存储用户请求的磁道号。
然后,将用户请求的磁道号加入队列中,按照先来先服务的原则进行服务,即按照队列中的请求顺序依次访问磁盘。
计算总体访问时间等信息,并输出结果。
2.SSTF(最短寻道时间优先)算法模拟实现:首先,我们需要定义一个队列,用于存储用户请求的磁道号。
然后,从当前磁头位置开始,找到与当前位置距离最近的请求磁道号,计算距离最小的请求所在的队列位置,并将该请求从队列中取出访问磁盘。
重复上述过程,直至队列为空。
计算总体访问时间等信息,并输出结果。
3.SCAN(扫描)算法模拟实现:首先,我们需要定义一个队列,用于存储用户请求的磁道号。
然后,将用户请求的磁道号加入队列中,并将队列按磁道号从小到大排序。
假设当前磁头位置为start,将磁头移动到队列中第一个比start大的磁道号,然后按照顺时针方向继续移动,直至访问队列中最大的磁道号。
然后,改变移动方向,回到队列中最小的磁道号为止。
计算总体访问时间等信息,并输出结果。
4.C-SCAN(循环扫描)算法模拟实现:首先,我们需要定义一个队列,用于存储用户请求的磁道号。
然后,将用户请求的磁道号加入队列中,并将队列按磁道号从小到大排序。
假设当前磁头位置为start,将磁头移动到队列中第一个比start大的磁道号,然后按照顺时针方向继续移动,直至访问队列中最大的磁道号,并将磁头移动到队列中最小的磁道号。
计算总体访问时间等信息,并输出结果。
以上是对于不同磁盘调度算法的简要模拟实现。
在实际应用中,还需要考虑更多的细节,如怎样处理新到的请求、队列的管理等。
C语言 磁盘调度算法 (FCFS SSTF SCAN CSCAN)

1.FCFS算法实现
2.SSTF算法实现
3.SCAN算法实现
4.CSCAN算法
5.显示对比表
=================================
【实验要求】可选编程语言:C/C++/Java/C#/Python;
实现在同一个程序文件中(C/C++);
请适当注释;
报告正文(运行屏幕截图及源代码)
{
sum += abs(track[i] - adress);
adress = track[i];
}
return sum;
}
int Get_SSTF_index(int t, int *flag)
{
int i, f = 0, min = 10000, juli = 0, l;
for(i = 0; i < 9; i++)
{
juli = abs(track[i] - t);
if(juli > 0 && juli < min && flag[i] ==0)
{
min = juli;
f = i;
}
}
return f;
}
bool IsEmpty(int *flag)
{
int i = 0;
for(i = 0; i < 9; i++)
一.截屏。
2.附录。
#include<stdio.h>
#include<Math.h>
static int track[9] = {55, 58, 39, 18, 90, 160, 150, 38, 184};
磁盘调度的实验报告(3篇)

第1篇一、实验目的1. 理解磁盘调度算法的基本原理和重要性。
2. 掌握几种常见的磁盘调度算法,包括先来先服务(FCFS)、最短寻道时间优先(SSTF)、扫描(SCAN)和循环扫描(C-SCAN)算法。
3. 通过模拟实验,分析不同磁盘调度算法的性能差异。
4. 优化磁盘调度策略,提高磁盘访问效率。
二、实验环境1. 操作系统:Windows 102. 编程语言:Python3.83. 磁盘调度算法模拟库:PyDiskScheduling三、实验内容1. FCFS算法:模拟实现先来先服务算法,按照请求顺序访问磁盘。
2. SSTF算法:模拟实现最短寻道时间优先算法,优先访问距离当前磁头最近的请求。
3. SCAN算法:模拟实现扫描算法,磁头从0号磁道开始向0号磁道移动,访问所有请求,然后返回到0号磁道。
4. C-SCAN算法:模拟实现循环扫描算法,与SCAN算法类似,但磁头在到达末尾磁道后返回到0号磁道。
四、实验步骤1. 导入PyDiskScheduling库。
2. 创建一个磁盘调度对象,指定磁头初始位置、请求序列和调度算法。
3. 运行调度算法,获取磁头移动轨迹和访问时间。
4. 分析算法性能,包括磁头移动次数、平均访问时间和响应时间等。
五、实验结果与分析1. FCFS算法:在请求序列较短时,FCFS算法表现较好。
但随着请求序列长度增加,磁头移动次数和访问时间明显增加。
2. SSTF算法:SSTF算法在请求序列较短时表现最佳,平均访问时间和响应时间较低。
但当请求序列较长时,算法性能下降,磁头移动次数增加。
3. SCAN算法:SCAN算法在请求序列较短时性能较好,但随着请求序列长度增加,磁头移动次数和访问时间逐渐增加。
与SSTF算法相比,SCAN算法在请求序列较长时性能更稳定。
4. C-SCAN算法:C-SCAN算法在请求序列较短时表现较好,但随着请求序列长度增加,磁头移动次数和访问时间逐渐增加。
与SCAN算法相比,C-SCAN算法在请求序列较长时性能更稳定,且磁头移动次数更少。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
磁盘调度算法的模拟实现学院专业学号学生姓名指导教师姓名2014年3月19日目录一、课设简介 (2)1.1 课程设计题目 (2)1.2 课程设计目的 (2)1.3 课程设计要求 (2)二、设计内容 (3)2.1功能实现 (3)2.2流程图 (3)2.3具体内容 (3)三、测试数据 (4)3.3 测试用例及运行结果 (4)四、源代码 (5)五、总结 (12)5.1 总结............................................一、课设简介1.1课程设计题目磁盘调度算法的模拟实现11.2程序设计目的操作系统课程设计是计算机专业重要的教学环节,它为学生提供了一个既动手又动脑,将课本上的理论知识和实际有机的结合起来,独立分析和解决实际问题的机会。
1)进一步巩固和复习操作系统的基础知识。
2)培养学生结构化程序、模块化程序设计的方法和能力。
3)提高学生调试程序的技巧和软件设计的能力。
4)提高学生分析问题、解决问题以及综合利用C语言进行程序设计的能力。
1.3 设计要求1)磁头初始磁道号,序列长度,磁道号序列等数据可从键盘输入,也可从文件读入。
2)最好能实现磁道号序列中磁道号的动态增加。
3)磁道访问序列以链表的形式存储4)给出各磁盘调度算法的调度顺序和平均寻道长度二、设计内容2.1 功能实现设计并实现一个本别利用下列磁盘调度算法进行磁盘调度的模拟程序。
1) 先来先服务算法FCFS 2) 最短寻道时间优先算法SSTF 2.2流程图2.3具体内容1)先来先服务算法FCFS这是一种比较简单的磁盘调度算法。
它根据进程请求访问磁盘的先后次序进行调度。
此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。
此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情开始 选择算法 F C F S S S T F 结束况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。
2)最短寻道时间优先算法SSTF该算法选择这样的进程,其要求访问的磁道与当前磁头所在的磁道距离最近,以使每次的寻道时间最短,该算法可以得到比较好的吞吐量,但却不能保证平均寻道时间最短。
其缺点是对用户的服务请求的响应机会不是均等的,因而导致响应时间的变化幅度很大。
在服务请求很多的情况下,对内外边缘磁道的请求将会无限期的被延迟,有些请求的响应时间将不可预期。
三、测试数据3.1 先来先服务算法输入磁道序列:55 58 39 18 90 160 150 38 184当前磁道号:1003.2 最短寻道时间优先算法(1)当前磁道号大于磁道序列中的最大的磁道号时输入磁道序列:55 58 39 18 90 160 150 38 184当前磁道号:1003.3 测试结果四、源代码#include<iostream>#include<cmath>#include<stdio.h> using namespace std;typedef struct node {int data;struct node *next;}Node,*Linklist;void main(){void Create_Linklist(Node *);void fcfs();//声明先来先服务函数FCFSvoid sstf();//声明最短寻道时间优先函数SSTFvoid print(Node *); //输出链表函数int s; //s是选择哪个算法printf("**************磁盘调度算法***************\n");printf("\t***1,先来先服务算法FCFS\n");printf("\t***2,最短寻道时间优先算法SSTF\n");printf("\t***0,退出\n");printf("\t***请选择:");scanf("%d",&s);while(s!=0){switch(s){case 1:printf("\t\t********你选择了:先来先服务算法FCFS\n");fcfs();break;case 2:printf("\t\t******你选择了:最短寻道时间优先算法SSTF\n");sstf();break;}printf("\t\t*******退出请选0,继续请选1,2,\n");scanf("%d",&s);}}/********************************************************** ********/void fcfs()//先来先服务算法{void Create_Linklist(Node *);void print(Node *);int Length_Linklist(Node *);Node *l,*head;//*m,*n;*/float num=0; //num为平均寻道长度int c,f;head=(Node *)malloc(sizeof(Node));head->next=NULL;printf("**************新建一个单链表,以0作为结束标志:********\n");Create_Linklist(head);c=Length_Linklist(head);printf("\t\t******从几号磁道开始:********");scanf("%d",&f); //f为磁道号print(head);printf("\t***链表长度为:%d\n",c);l=head->next;for(int i=0;i<c;i++){num+=abs(l->data-f);f=l->data;l=l->next;}num=num/c;printf("\t\t*****先来先服务的寻道顺序是:\n");print(head);printf("\t\t******平均寻道长度:%f\n",num);}/********************************************************** *******/void sstf()//最短寻道时间优先算法{void Create_Linklist(Node *);void print(Node *);int Length_Linklist(Node *);Node *p,*q,*r,*s,*l,*m,*head;int c,f;head=(Node *)malloc(sizeof(Node));head->next=NULL;printf("**************新建一个单链表,以0作为结束标志:********\n");Create_Linklist(head);c=Length_Linklist(head);printf("\t\t******从几号磁道开始:********");scanf("%d",&f); //f为磁道号print(head);printf("\t***链表长度为:%d\n",c);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;printf("\t\t******最短寻道时间优先顺序是:\n");print(l);printf("\t\t*********平均寻道长度:%f\n",num);}/*********************************************************/ void print(Node *head) //输出链表{Node *p;p=head->next;cout<<"单链表显示:";if(p==NULL){printf("单链表为空:\n");}else if(p->next==NULL){ printf("%d\t",p->data);printf("\n");}else{while(p->next!=NULL){printf("%d\t",p->data);p=p->next;}printf("%d\t",p->data);printf("\n");}}/*********************************************************/ void Create_Linklist(Node *head)//创建链表{Node *p,*q;int i;scanf("%d",&i);q=head;while(i!=0){p=(Node *)malloc(sizeof(Node));p->next=NULL;p->data=i;q->next=p;q=p;cin>>i;}/* c++;*/}/**************************************************/int Length_Linklist(Node *head)//计算链表长{int l;Node *p;p= head->next;l=1;while(p->next){p=p->next;l++;}return l;}五、总结通过此次课程设计,我对操作系统的基础知识了解得更透彻了,同时对磁盘调度的四种算法——先来先服务算法(FCFS)、最短寻道时间优先算法(SSTF)、有了更深刻的理解和掌握,使我能够为磁盘调度选择适当的算法,提高CPU工作效率。