实验七磁盘调度
磁盘调度
磁盘调度1设计目的(1)要求学生设计一个模拟磁盘调度的程序。
(2)理解磁盘调度过程中的三个时间段。
(3)理解磁盘调度的三种算法。
2实验原理共享设备的典型代表磁盘,磁盘的物理块的地址由柱面号、磁头号、扇区号来指定,完成磁盘某一个物理块的访问要经过三个阶段:寻道时间Ts、旋转延迟Tw和读写时间Trw。
寻道时间Ts是磁头从当前磁道移动到目标磁道所需要的时间;旋转延迟Tw是当磁头停留在目标磁道后,目标物理块从当前位置旋转到磁头位置的时间;读写时间Trw是目标物理块内容与内存中对应交换的时间。
磁盘调度的原则是公平和高吞量,衡量指标有访问时间T 和平均访问时间Ta:T=Ts+Tw+TrwT=Tsa+Twa+Trwa寻道时间和旋转延迟为调度算法的主要考虑因素。
减少访问时间就是要减少寻道时间和旋转延迟。
3设计要求(1)设计一个函数完成先来先服务的磁盘调度功能。
(2)设计一个函数完成最短寻道时间优先的磁盘调度功能。
(3)设计一个函数完成电梯算法的磁盘调度功能。
4环境操作系统WindowsXP,开发工具VC++6.0或者BCB6.0。
5步骤(1)打开VC,选择菜单项File→New,选择Project选项卡并建立一个名为cidao的win32 console application工程。
(2)在工程中创建原文件cidao.cpp:选择菜单项Project→Add to Project→File,此时将打开一个新窗口,在其中输入想要创建的文件名字,这里是cidao.cpp,其中编辑好原文件并保存。
(3)通过调用菜单项Build→Rebuild all进行编译连接,可以在指定的工程目录下得到debug→cidao.exe程序,可以在控制台进入该debug 目录运行程序。
6运行结果分析FCFS将申请磁盘服务的进程按先后顺序排队,每次调度选择位于队首的进程运行。
请求的先后顺序是18,5,23,8,16。
可以计算出所有进程运行后磁头一共移动的磁道数:13+18+15+8=54(见图12.12)。
磁盘调度操作系统实验报告
磁盘调度操作系统实验报告一、实验目的:本次实验主要目的是通过模拟实现磁盘调度算法,加深对操作系统磁盘调度原理的理解,并学会使用操作系统磁盘调度算法解决实际问题。
二、实验内容:1.磁盘调度算法原理分析:磁盘调度算法是操作系统中的重要组成部分,它的任务是合理安排磁盘上数据的存取顺序,以提高磁盘的效率。
常见的磁盘调度算法有先来先服务(FCFS)、最短寻道时间优先(SSTF)、电梯算法(SCAN)等。
2.模拟实现磁盘调度算法:本实验选择最短寻道时间优先算法(SSTF)作为示例进行模拟实现。
SSTF算法的原理是优先选择离当前磁头位置最近的磁道进行访问,以减少磁头移动时间。
实验步骤:1.根据实际情况,创建一个磁道队列,记录需要访问的磁道序号。
2.初始化磁盘的起始位置和访问队列。
3.对访问队列进行排序,按照磁头当前位置到磁道的距离从小到大排列。
4.根据排序后的队列顺序,依次访问磁道,并记录磁头移动的距离。
5.计算平均寻道长度。
三、实验结果分析:通过模拟实现SSTF磁盘调度算法,我们获得了磁头对每个磁道的访问顺序和总共的磁头移动距离。
根据实验结果,我们可以发现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算法通过选择离当前磁道最近的请求进行处理,能够减少平均寻道时间,提高磁盘性能。
五、实验总结通过本次实验,我们学习了操作系统中磁盘调度算法的原理和实现过程。
不同的磁盘调度算法具有不同的优缺点,我们需要根据实际情况选择合适的算法。
磁盘调度实验报告
操作系统实验报告课程名称:计算机操作系统实验项目名称:磁盘调度实验时间:班级:姓名:学号:实验目的:对操作系统的磁盘调度基础理论和重要算法的理解,加强动手能力。
实验环境:PC机 win7 Visual C++实验内容:编程序实现下述磁盘调度算法,并求出每种算法的平均寻道长度,要求设计主界面以灵活选择某算法,且以下算法都要实现:1、先来先服务算法(FCFS)2、最短寻道时间优先算法(SSTF)3、扫描算法(SCAN)4、循环扫描算法(CSCAN)实验过程:1.依次输入8个磁道数:123 45 31 67 20 19 38,并以0 结束2.选择调度算法:(1)先来先服务算法(FCFS)(2)最短寻道时间优先算法(SSTF)成绩:指导教师(签名):(3)扫描算法(SCAN)(4)循环扫描算法(CSCAN)实验心得:通过本次实验,学习了解磁盘调度的工作原理及四种调度方法的工作原理,并且在当中发现了自己的不足,对以前所学过的知识理解得不够深刻,掌握得不够牢固,看到了自己的实践经验还是比较缺乏,理论联系实际的能力还急需提高。
附录:#include<stdio.h>#include<stdlib.h>#include<iostream.h>#include<math.h>#define maxsize 1000/*********************判断输入数据是否有效**************************/int 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;}/*********************先来先服务调度算法**************************/void FCFS(int cidao[],int m) //磁道号数组,个数为m{int now;//当前磁道号int sum=0; //总寻道长度int j,i;int a;char str[100];float ave; //平均寻道长度cout<<" 磁盘请求序列为:";for( i=0;i<m;i++) //按先来先服务的策略输出磁盘请求序列{cout<<cidao[i]<<" ";}cout<<endl;cout<<" 请输入当前的磁道号:";B: cin>>str; //对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<<endl;goto B;}elsenow=trans(str,a); //输入当前磁道号sum+=abs(cidao[0]-now);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 i,j,sum=0;int a;char str[100];float ave;cidao=bubble(cidao,m); //调用冒泡排序算法排序cout<<" 请输入当前的磁道号:";C: cin>>str; //对输入数据进行有效性判断a=decide(str);if(a==0){cout<<" 输入数据的类型错误,请重新输入!"<<endl;goto C;}elsenow=trans(str,a); //输入当前磁道号if(cidao[m-1]<=now) //若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务{ cout<<" 磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<<cidao[i]<<" ";sum=now-cidao[0];}if(cidao[0]>=now) //若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务{cout<<" 磁盘扫描序列为:";for(i=0;i<m;i++)cout<<cidao[i]<<" ";sum=cidao[m-1]-now;}if(now>cidao[0]&&now<cidao[m-1]) //若当前磁道号大于请求序列中最小者且小于最大者{ cout<<" 磁盘扫描序列为:";while(cidao[k]<now) //确定当前磁道在已排的序列中的位置,后面的算法都用到了,可以直接复制后少量修改,节省时间。
磁盘调度实验报告实验总结
磁盘调度实验报告实验总结磁盘调度是操作系统中的一个重要概念,它是指操作系统通过合理的算法和策略来管理和调度磁盘上的数据访问请求。
磁盘调度的目的是提高磁盘的读写效率,减少磁盘访问的时间开销,从而提高系统的整体性能。
本次实验主要对比了三种常见的磁盘调度算法:先来先服务(FCFS)、最短寻道时间优先(SSTF)和电梯算法(SCAN)。
通过对比实验结果分析各种算法的性能表现和特点,并给出相应的实验总结。
实验总结如下:一、先来先服务(FCFS)算法FCFS算法是一种简单直接的磁盘调度算法,它按照请求的顺序依次进行访问。
实验结果表明,FCFS算法的平均寻道时间较高,且易产生长期等待现象。
这是因为FCFS算法无法优化磁头的移动顺序,只能按照请求的先后顺序安排磁道的访问,从而导致了较差的性能表现。
二、最短寻道时间优先(SSTF)算法SSTF算法根据当前磁头位置选择距离最近的请求进行服务。
实验结果表明,SSTF算法的平均寻道时间明显优于FCFS算法,且缓解了长期等待现象。
这是因为SSTF算法可以选择离当前磁头位置最近的请求,从而减少了寻道时间,提高了磁道的访问效率。
三、电梯算法(SCAN)算法SCAN算法也称为电梯算法,它模拟了电梯运行的原理。
SCAN算法先将磁头移动到一个极限位置,然后沿着一个方向依次访问请求,直到到达另一个极限位置,再改变方向重复上述过程。
实验结果表明,SCAN算法的平均寻道时间与SSTF 算法相当,且具有较好的均衡性。
这是因为SCAN算法可以使得磁头在磁盘上的行进路线保持平衡,避免了过多的磁道之间的跳跃,从而提高了磁道的访问效率。
综上所述,不同的磁盘调度算法具有不同的性能表现和特点。
在实际应用中,需要根据具体的场景和需求选择合适的磁盘调度算法。
一般而言,SSTF算法和SCAN算法在性能上表现较好,可以提高磁盘的读写效率,减少寻道时间开销。
而FCFS算法在实际应用中较为有限,对于长期等待和寻道时间要求较高的场景不太适用。
磁盘调度算法
磁盘调度算法As a person, we must have independent thoughts and personality.操作系统实验报告哈尔滨工程大学计算机科学与技术学院一、实验概述1. 实验名称磁盘调度算法2.实验目的(1)通过学习EOS实现磁盘调度算法的机制,掌握磁盘调度算法执行的条件和时机。
(2)观察EOS实现的FCFS、SSTF和 SCAN磁盘调度算法,了解常用的磁盘调度算法。
(3)编写CSCAN和N-Step-SCAN磁盘调度算法,加深对各种扫描算法的理解。
3. 实验类型验证,设计4. 实验内容(1)准备实验(2)验证先来先服务(FCFS)磁盘调度算法(3)验证最短寻道时间优先(SSTF)磁盘调度算法(4)验证SSTF算法造成的线程“饥饿”现象()验证扫描(SCAN)磁盘调度算法()验证SCAN 算法能够解决“饥饿”现象(6)改写SCAN调度算法二、实验环境EOS操作系统与IDE环境组成的“操作系统集成实验环境OS Lab”。
三、实验过程(一)实验问题及解答1.实验指导验证先来先服务(FCFS)磁盘调度算法,要求请给出在“输出”窗口中的结果。
答:输出结果复制如下:制作软盘镜像...正在启动 Virtual PC...开始调试...****** Disk schedule start working ******Start Cylinder: 10TID: 31 Cylinder: 8 Offset: 2 -TID: 32 Cylinder: 21 Offset: 13 +TID: 33 Cylinder: 9 Offset: 12 -TID: 34 Cylinder: 78 Offset: 69 +TID: 35 Cylinder: 0 Offset: 78 -TID: 36 Cylinder: 41 Offset: 41 +TID: 37 Cylinder: 10 Offset: 31 -TID: 39 Cylinder: 12 Offset: 55 -TID: 40 Cylinder: 10 Offset: 2 -Total offset: 360 Transfer times: 10 Average offset: 362.实验指导验证验证最短寻道时间优先(SSTF)磁盘调度算法,要求请给出在“输出”窗口中的结果。
磁盘调度的实验报告(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. 算法原理在磁盘调度算法中,我们主要讨论了FCFS(先进先出)、SSTF(最短寻道时间优先)、SCAN(扫描)、C-SCAN(循环扫描)和LOOK(LOOK扫描)等算法。
这些算法的主要思想是通过不同的方式优化磁盘读/写请求的寻道时间,从而提高磁盘的I/O性能。
3. 实验环境实验环境包括一台服务器和一块磁盘。
服务器上安装了Linux操作系统,并使用C语言编写了磁盘调度算法的模拟程序。
磁盘具有多个柱面,每个柱面包含多个块。
4. 实验过程在实验过程中,我们首先对FCFS、SSTF、SCAN、C-SCAN和LOOK等算法进行了模拟。
然后,我们根据不同的磁盘读写请求,使用不同的算法进行寻道时间模拟。
最后,我们对模拟结果进行了分析和比较。
5. 实验结果通过模拟实验,我们得到了不同算法在不同磁盘读写请求下的寻道时间。
实验结果表明,SCAN和C-SCAN算法在平均寻道时间上表现较好,而SSTF算法在局部请求密集的情况下表现较好。
同时,我们发现FCFS算法的性能最差。
6. 性能比较通过对不同算法的寻道时间进行比较,我们发现SCAN 和C-SCAN算法在平均寻道时间上表现较好。
这是因为它们能够根据磁盘头部的移动方向来优化寻道时间。
而SSTF算法在局部请求密集的情况下表现较好,因为它的策略是优先寻找最近未被访问的柱面,这可以减少磁盘头部的移动距离。
然而,FCFS算法的性能最差,因为它总是按照请求的顺序进行寻道,没有考虑到磁盘头部的移动方向和局部请求的密集程度。
7. 结论通过本次实验,我们深入了解了不同磁盘调度算法的性能差异。
SCAN和C-SCAN算法在平均寻道时间上表现较好,适用于需要平衡寻道时间和I/O性能的情况;而SSTF算法在局部请求密集的情况下表现较好,适用于需要快速响应局部请求的情况。
实习磁盘调度心得体会
实习磁盘调度心得体会在磁盘调度算法的研究中,我对几种常见的磁盘调度算法进行了深入的研究,包括FCFS算法、SSTF算法、SCAN算法等。
我发现不同的磁盘调度算法在不同的场景下有着不同的优势和劣势。
比如,在磁盘上存在大量随机访问的情况下,SSTF算法能够在短时间内完成大量的访问请求,而在需要保证公平性的情况下,SCAN算法能够更好地平衡磁盘上各个磁道的访问次数。
通过对这些算法的研究,我对磁盘调度算法的优缺点有了更清晰的认识,并且在实际工作中能够更好地根据具体情况选择合适的算法。
在实习期间,我还遇到了一些实际工作中的问题,比如磁盘访问速度过慢、磁盘上存在大量碎片等。
为了解决这些问题,我结合自己的理论知识,对实际情况进行了分析和实验,并且提出了一些解决方案。
比如,在面对磁盘访问速度过慢的问题时,我通过优化磁盘的物理结构和调整磁盘调度算法的参数,使得磁盘的访问速度得到了明显的提升。
在解决磁盘碎片问题时,我采用了磁盘碎片整理的方法,通过对磁盘上的文件进行整理和整合,有效地减少了磁盘碎片的数量,提高了磁盘的读写速度。
通过这些实际问题的解决,我对磁盘调度算法的实际应用有了更深入的理解,也积累了一定的经验。
在未来的工作中,我将继续深入研究磁盘调度算法,探索更加高效的解决方案,为提高系统的性能和稳定性做出更大的贡献。
除了在磁盘调度算法的研究和应用方面有所收获外,我在实习期间还学到了很多关于团队合作和沟通的经验。
在团队中,我们每个人都有着不同的专业背景和技能,而且我们互相之间还存在着一定的交流和合作障碍。
为了更好地完成项目任务,我学会了更加主动地和团队成员进行沟通,及时解决问题和分配任务,保证整个团队能够高效地协作。
另外,我还意识到了自身的不足,比如在团队合作中缺乏主动性和领导能力。
在今后的工作中,我将更加努力地提升自己的团队合作能力和领导能力,争取成为更有价值的团队成员。
通过这段时间的实习,我对自己的职业发展方向有了更清晰的认识,也对未来的职业规划有了更明确的目标。
磁盘调度实验报告_4
磁盘调度一、实验目的:磁盘是高速、大容量、旋转型、可直接存取的存储设备。
它作为计算机系统的辅助存储器, 担负着繁重的输入输出工作, 在现代计算机系统中往往同时会有若干个要求访问磁盘的输入输出要求。
系统可采用一种策略, 尽可能按最佳次序执行访问磁盘的请求。
由于磁盘访问时间主要受寻道时间T的影响, 为此需要采用合适的寻道算法, 以降低寻道时间。
本实验要求学生模拟设计一个磁盘调度程序, 观察调度程序的动态运行过程。
通过实验让学生理解和掌握磁盘调度的职能。
二、概要设计:要求设计主界面能灵活选择某算法, 且实现以下算法:(1)先来先服务算法(FCFS)(2)最短寻道时间优先算法(SSTF)(3)扫描算法(SCAN)(4)循环扫描算法(CSCAN)本系统划分为四个模块: 先来先服务算法模块void FCFS(int array[],int m)、最短寻道时优先算法模块void SSTF(int array[],int m)、扫描算法模块void SCAN(int array[],int m)、循环扫描算法模块void SCAN(int array[],int m)设备的动态分配算法与进程调度相似, 也是基于一定的分配策略的。
常用的分配策略有先请求先分配、优先级高者先分配等策略。
在多道程序系统中, 低效率通常是由于磁盘类旋转设备使用不当造成的。
操作系统中, 对磁盘的访问要求来自多方面, 常常需要排队。
这时, 对众多的访问要求按一定的次序响应, 会直接影响磁盘的工作效率, 进而影响系统的性能访问磁盘的时间因子由3部分构成, 它们是:查找(查找磁道)时间、等待(旋转等待扇区)时间和数据传输时间, 其中查找时间是决定因素。
因此, 磁盘调度算法先考虑优化查找策略, 需要时再优化旋转等待策略。
平均寻道长度(L)为所有磁道所需移动距离之和除以总的所需访问的磁道数(N), 即:(M1+M2+……+Mi+……+MN)/N 其中Mi为所需访问的磁道号所需移动的磁道数。
磁盘调度算法实验报告
磁盘调度算法实验报告磁盘调度算法实验报告引言:磁盘调度算法是操作系统中的重要组成部分,它负责决定磁盘上数据的访问顺序,以提高磁盘的访问效率。
在本次实验中,我们对比了三种常见的磁盘调度算法:先来先服务(FCFS)、最短寻道时间优先(SSTF)和扫描(SCAN)算法。
通过对比实验结果,我们将分析不同算法的优缺点,并对其适用场景进行探讨。
实验过程:为了模拟磁盘调度算法在实际应用中的情况,我们使用了一个包含100个磁道的磁盘模型。
我们随机生成了一组磁道请求序列,并以此作为实验数据。
首先,我们使用FCFS算法对数据进行访问,记录下访问每个磁道所需的时间。
然后,我们分别使用SSTF和SCAN算法进行同样的操作,并记录下相应的访问时间。
实验结果:经过实验,我们得到了不同调度算法的访问时间数据。
在FCFS算法中,由于它按照请求的先后顺序进行访问,所以磁头需要频繁地在磁道之间移动,导致访问时间较长。
SSTF算法则根据当前磁头位置选择最近的磁道进行访问,因此其访问时间相对较短。
而SCAN算法则将磁头从一端移动到另一端,期间访问所有请求的磁道,这样可以减少磁头的移动次数,从而提高访问效率。
讨论与分析:从实验结果可以看出,不同的磁盘调度算法在不同的场景下有着不同的优势。
FCFS算法适用于请求较少、请求之间没有明显关联的情况。
因为它简单易实现,不需要额外的计算和判断,但在高负载情况下容易导致磁头抖动,降低整体性能。
SSTF算法适用于请求之间有明显关联的情况,因为它能够选择最近的磁道进行访问,减少了磁头的移动次数。
但是,当请求分布不均匀时,SSTF算法可能会导致某些磁道长时间得不到访问。
SCAN算法则适用于对整个磁盘进行扫描的场景,因为它能够在一个方向上连续访问多个磁道,减少了磁头的移动次数。
但是,SCAN算法可能会导致某些磁道长时间得不到访问,因此在请求分布不均匀的情况下,其性能可能会受到影响。
结论:通过本次实验,我们对比了三种常见的磁盘调度算法,并分析了它们的优缺点及适用场景。
实验七 磁盘调度算法的实现
实验七磁盘调度算法的实现
1、实验目的
(1)通过编写和调试磁盘调度算法的模拟程序以加深对磁盘调度算法的理解;
(2)熟悉FCFS磁盘调度算法的原理;
(3)了解磁盘中存取数据过程。
2、实验要求
编写并调试一个磁盘调度模拟程序,采用FCFS算法。
已知进程号及进程先后要访问的磁道数、磁头当前位置,要求使用FCFS算法输出磁头移动的磁道数和平均寻道数。
3、算法描述
先来先服务(FCFS,First Come First Served),这是一种最简单的磁盘调度算法。
它根据进程请求访问磁盘的先后次序进行调度。
此算法的优点是公平、简单,且每个进程的请求都能依次地得到处理,不会出现某一进程的请求长期得不到满足的情况。
下图示出了有9个进程先后提出磁盘I/O请求时,当前磁道为100,按FCFS算法进行调度的情况。
(FCFS算法平均寻道距离较大,故FCFS算法仅适用于请求磁盘I/O的进程数目较少的场合。
)
4、源程序代码(同学们自己给出)
附加:课间或课后完成内容
(1)其它调度算法如SSTF的实现;(2)画出磁头的移动轨迹图。
磁盘调度
题目8 磁盘调度一、实验目的1、对磁盘调度的相关知识作进一步的了解,明确磁盘调度的原理。
2、加深理解磁盘调度的主要任务。
3、通过编程,掌握磁盘调度的主要算法。
二、实验内容和要求1、对于如下给定的一组磁盘访问进行调度:要求分别采用先来先服务、最短寻道优先以及电梯调度方法进行调度。
3、要求给出每种算法中磁盘访问的顺序,计算出平均移动道数。
4、假定当前读写头在90号,向磁道号增加的方向移动。
三、实验报告1、程序中使用的数据结构及符号说明。
2、给出主要算法的流程图。
3、给出程序清单并附上注释。
4、给出测试数据和运行结果。
程序:#include<>#include<>#define N 11void main(){//请求服务到达 A B C D E F G H I J K //访问的磁道号30 50 100 180 20 90 150 70 80 10 160//要求给出每种算法中磁盘访问的顺序,计算出平均移动道数。
//假定当前读写头在号,向磁道号增加的方向移动。
//初始化int track[N],track2[N+1];int i ;printf("请输入访问磁道序列:\n");for (i=0;i<N;i++){scanf("%d",&track[i]);track2[i] = track[i] ;}//先来先服务printf("先来先服务:");for (i=0;i<N;i++){printf("%d ",track[i]);}double s = abs(90-track[0]) ;for (i=0;i<=N-2;i++){s += abs(track[i]-track[i+1]) ;}printf("\n平均移动磁道数:%\n\n",s/N);//最短寻道优先s = 0 ;printf("最短寻道优先:");int temp[N];track2[N] = 90 ;int k = N ; //当前磁道int flag ; //标志int min; //最小差值int t ; //最小差值的数组下标int j;for (j=0 ; j<N ;j++ ){flag = 0;for (i=0;i<N;i++){if((i!=k)&&flag==0&& track2[i]!=-1){min = abs(track2[i]- track2[k]);t = i;flag++;}if((i!=k)&&(track2[i]!=-1)&&(abs(track2[i]-track2[k]) < min ) ){min =abs(track2[i]-track2[k]);t = i;}}s += min ;temp[j] = t ;track2[k] = -1 ;k = t ;}for(i=0;i<N;i++)printf("%d ",track[temp[i]]);printf("\n平均移动磁道数:%\n\n",s/N);//电梯调度方法s = 0 ;printf("电梯调度:");for (i=0;i<N-1;i++){for (j=0;j<N-i-1;j++){if (track[j]>track[j+1]){t=track[j];track[j]= track[j+1];track[j+1]=t;}}}for (i=0;i<N;i++){if (track[i]>90)break;}for (j=i;j<N;j++)printf("%d ",track[j]);for(j=i-1;j>=0;j--)printf("%d ",track[j]);s = (track[N-1]-90)+(track[N-1]-track[0]);printf("\n平均移动磁道数:%",s/N);printf("\n");}运行结果:。
磁盘调度实验报告
磁盘调度实验报告一、实验目的1.掌握磁盘调度算法的基本原理和思想;2.理解磁盘调度算法的性能指标及其关系;3.利用实验验证各种磁盘调度算法的性能差异。
二、实验原理磁盘调度算法是操作系统中用来调度磁盘的读写操作的一种方法。
磁盘访问的时间主要包括寻道时间、旋转延迟和数据传输时间。
磁盘调度算法的目标是尽可能减少磁头的移动和等待时间,提高磁盘的访问效率。
常用的磁盘调度算法有先来先服务(FCFS)、最短寻找时间优先(SSTF)、电梯扫描(SCAN)和循环扫描(CSCAN)等。
FCFS算法就是按照请求的先后顺序进行访问,即先来的请求先执行。
SSTF算法每次选择最短寻找时间的磁道进行访问,减少了寻道时间。
SCAN算法则是磁头按照一个方向进行扫描,直到扫描到磁盘的一侧,然后改变方向继续扫描。
CSCAN算法是类似于SCAN算法,只是当扫描到磁盘的一侧时,直接跳到另一侧进行扫描。
这些算法各有优缺点,适用于不同的场景和需求。
三、实验过程1.实验环境搭建:选择一台计算机作为实验机器,安装操作系统和相应的磁盘调度算法软件;2.实验数据准备:生成一组磁道访问的请求序列,包括请求的磁道号和读写操作;3.实验数据输入:将生成的请求序列输入到磁盘调度软件中,选择不同的调度算法进行模拟;4.实验结果记录:记录各种调度算法的磁头移动次数和平均访问时间;5.实验数据分析:根据实验结果进行数据分析,比较各种算法的性能差异。
四、实验结果分析根据实验数据进行结果分析,比较不同调度算法的性能差异。
以磁头移动次数和平均访问时间为评价指标,可以看出不同算法对磁盘访问的影响。
在一些情况下,可能一些算法的磁头移动次数更少,但平均访问时间可能并不是最低的,需要综合考虑多个因素。
根据实验结果可以发现,FCFS算法的磁头移动次数和平均访问时间相对较高,因为它只按照请求的先后顺序进行访问,没有考虑磁道之间的距离。
SSTF算法在减少磁头移动次数和平均访问时间方面有一定的优势,因为它每次选择最短寻找时间的磁道进行访问。
实验磁盘调度算法
实验七:磁盘调度算法目录一.实验目的加深对磁盘的工作原理和调度效率的理解,掌握各种磁盘调度算法,模拟实现一种磁盘调度算法<SSTF、SCAN、CSCAN等)。
二.实验属性该实验为设计性实验。
三.实验仪器设备及器材普通PC386以上微机四.实验内容<1)先来先服务算法<FCFS)<2)最短寻道时间优先算法<SSTF)<3)扫描算法<SCAN)<4)循环扫描算法<CSCAN)五.实验步骤。
<1)先来先服务调度算法<FCFS)void FCFS(int a[],int n>{int sum=0,j,i,first=0,now。
cout<<"请输入当前磁道号:"。
cin>>now。
//确定当前磁头所在位置cout<<"磁盘调度顺序为:"<<endl。
for( i=0。
i<n。
i++>//按访问顺序输出磁道号{cout<<a[i]<<" "。
}//计算sumfor(i=0,j=1。
j<n。
i++,j++>{first+=abs(a[j]-a[i]>。
//外围磁道与最里面磁道的距离}sum+=first+abs(now-a[0]>。
cout<<endl。
cout<<"移动的总磁道数: "<<sum<<endl。
}<2)最短寻道时间算法<SSTF)void SSTF(int a[],int n>{int temp。
int k=1。
int now,l,r。
int i,j,sum=0。
//将磁道号按递增排序for(i=0。
i<n。
i++>for(j=i+1。
j<n。
j++>{if(a[i]>a[j]>{temp=a[i]。
操作系统实验磁盘调度算法实验报告
操作系统实验磁盘调度算法实验报告一.实验目的本实验旨在通过磁盘调度算法的模拟,探究不同调度算法对磁盘访问性能的影响,了解各种算法的特点和适用场景。
二.实验方法本实验通过编写磁盘调度模拟程序,实现了三种常见的磁盘调度算法:FCFS(先来先服务)、SSTF(最短寻找时间优先)和SCAN(扫描算法)。
实验中使用C语言编程语言,并通过随机生成的队列模拟磁盘访问请求序列。
三.实验过程1.FCFS(先来先服务)算法FCFS算法是一种非常简单的调度算法,它按照请求到达的顺序进行调度。
在实验中,我们按照生成的请求队列顺序进行磁盘调度,记录每次磁头移动的距离。
2.SSTF(最短寻找时间优先)算法SSTF算法是一种动态选择离当前磁头位置最近的磁道进行调度的算法。
在实验中,我们根据当前磁头位置和请求队列中的磁道位置,选择距离最近的磁道进行调度。
然后将该磁道从请求队列中移除,并记录磁头移动的距离。
3.SCAN(扫描算法)算法SCAN算法是一种按照一个方向进行扫描的算法,它在每个方向上按照磁道号的顺序进行调度,直到扫描到最边缘磁道再折返。
在实验中,我们模拟磁头从一个端点开始,按照磁道号从小到大的顺序进行调度,然后再折返。
记录磁头移动的距离。
四.实验结果与分析我们通过生成不同数量的请求队列进行实验,记录每种算法的磁头移动距离,并进行比较。
实验结果显示,当请求队列长度较小时,FCFS算法的磁头移动距离较短,因为它按照请求到达的顺序进行调度,无需寻找最短的磁道。
然而,当请求队列长度较大时,FCFS算法的磁头移动距离会显著增加,因为它不能根据距离进行调度。
SSTF算法相对于FCFS算法在磁头移动距离上有了明显改进。
SSTF算法通过选择最短的寻找时间来决定下一个访问的磁道,因此可以减少磁头的移动距离。
然而,在请求队列中存在少量分散的请求时,SSTF算法可能会产生扇区的服务死锁现象,导致一些磁道无法及时访问。
SCAN算法通过扫描整个磁盘来进行调度,有效解决了FCFS算法有可能导致的服务死锁问题。
磁盘调度实验报告
磁盘调度实验报告磁盘调度实验报告一、引言磁盘调度是操作系统中的一个重要组成部分,其作用是对磁盘上的数据进行合理的调度和管理,以提高磁盘的读写效率。
本文将对磁盘调度实验进行详细的分析和总结,探讨不同的磁盘调度算法对磁盘性能的影响。
二、实验目的本次实验的目的是通过模拟不同的磁盘调度算法,比较它们在不同情况下的性能表现,包括平均寻道时间、平均旋转延迟时间和平均访问时间等指标。
通过实验结果的对比分析,我们可以了解不同磁盘调度算法的优劣,并选择适合特定应用场景的磁盘调度算法。
三、实验环境和方法本次实验使用了模拟磁盘调度的软件,并设置了不同的磁盘调度算法进行对比。
实验环境为一台配置良好的计算机,操作系统为Windows 10。
实验方法是通过设置不同的磁盘访问序列,模拟磁盘的读写操作,并记录相应的性能指标。
四、实验结果和分析在本次实验中,我们选择了三种常见的磁盘调度算法进行对比,分别是先来先服务(FCFS)、最短寻道时间优先(SSTF)和电梯算法。
下面将分别对这三种算法的实验结果进行分析。
1. 先来先服务(FCFS)先来先服务算法是最简单的一种磁盘调度算法,它按照请求的顺序进行调度。
实验结果显示,当磁盘访问序列较为随机时,FCFS算法的性能表现较差。
这是因为当磁盘访问序列随机时,FCFS算法无法充分利用磁盘的局部性原理,导致平均寻道时间较长。
2. 最短寻道时间优先(SSTF)最短寻道时间优先算法是一种比较常用的磁盘调度算法,它选择离当前磁头位置最近的磁道进行访问。
实验结果显示,SSTF算法在随机磁盘访问序列下表现优秀,平均寻道时间较短。
这是因为SSTF算法能够充分利用磁盘的局部性原理,尽可能减小寻道时间。
3. 电梯算法电梯算法是一种比较灵活的磁盘调度算法,它模拟了电梯的运行方式。
当磁头移动的方向没有改变时,电梯算法按照最短寻道时间优先的原则进行调度;当磁头移动的方向改变时,电梯算法改变调度方向,并按照当前方向上最远的磁道进行访问。
实验七 磁盘调度管理实现
计算机操作系统综合设计实验七实验名称:磁盘调度管理实现学号:学生姓名:班级:指导教师:实验地点:实验日期:评分:一、实验目的1)理解磁盘调度相关理论;2)掌握多种磁盘调度算法;3)彻底掌握SCAN磁盘调度算法。
二、实验平台windows 10Visual C++ 6.0三、实验步骤1、实验内容1)设计磁盘调度请求队列(请求数≥10);2)设定单位寻道时间;3)可动态修改磁盘请求时间和磁道;4)实现SCAN磁盘调度算法;5)实现动态调度并输出调度序列。
2、实验步骤1)编写并输入代码A、打开Visual C++ 6.0;B、新建c++文件,创建scan.cp。
2)进行功能测试并得出正确结果A、编译、运行scan.cpp:B、输入当前磁道号:C、输入队列:D、显示移动过程,以及平均寻道长度:E、改变队列长度,增加一个磁道号。
F、不改变长度,修改序列号为2的磁道号:G、修改磁头号的位置:四、实验总结整个设计中最麻烦的就是整个程序模块的划分和各模块之间接口设计,编程中经常犯想当然的错误,编程中出现了不少奇怪的错误。
再调试中尝试使用了分割法,对错误模块进行定位,再进行排查.通过这次的课程设计使我认识到要将操作系统这门计算机专业的课学好不仅仅是要把书上的基本知识学好而且还要不断进行实践,将所学的跟实践操作结合起来才能更好地巩固所学,才能提高自己实践能力.通过这次的设计使我认识到只停留在表面理解问题是很难使问题得到很好的解决的,实践能力与理论知识同样重要。
可以说此课程设计的理论难度并不大,但是若要深入发掘其中的东西,并且实际去编程实现,就遇到了相当大的难度。
因为与之涉及的很多方面并没有学过,需要自己去自学和实践检验。
,通过模拟磁盘调度及进程排队算法来加深对操作系统中各个磁臂调度算法概念的理解。
模拟磁盘调度算法(FCFS,SSTF,SCAN,CSCAN),实现各种不同调度算法的过程,并计算各算法的平均寻道长度,以便于我们判断各种算法的优劣以及各种算法使用的场合。
磁盘调度实现
实验七:磁盘调度算法一、目的理解磁盘调度原理。
二、实验内容实现SSTF算法和SCAN算法。
三、实验要求测试:设有100个磁道,访问序列如下:23,5,98,14,66,25,78,34,66,74,56,87,12,39,71,49,58当前磁头在50道,上次访问的磁道是18道。
四、实验代码#include"stdio.h"void scan(int star, int *rom, int n){int i, j;for( i=0; i<n; i++)//寻找star在rom中的位置{if(rom[i]>=star) break;}for( j = i; j<n; j++)//输出star右边的数{printf("%d ", rom[j]);}for( j=i-1; j>=0; j--)//输出star左边的数{printf("%d ", rom[j]);}printf("\n\n");}void sstf(int star, int *rom, int n){int temp, i, min, j=0, k;for( i=0; i<n; i++)//寻找star在有序rom中的位置{if(rom[i]>=star) break;}j = i-1;while(j>=0 || i<n)//寻找距star最近的磁道{if( (i<n && j>=0 &&(star - rom[j] > rom[i]-star)) || j<0 ){//star左右都有未访问的磁道且右边的距star较近,或者satr只有右边有未访问的磁道star = rom[i];printf("%d ", rom[i++]);}else{//star左右都有未访问的磁道且左边的距star较近,或者satr只有左边有未访问的磁道star = rom[j];printf("%d ", rom[j--]);}}printf("\n\n");}void sort(int *rom, int n)//选择排序{int i, j, min, k, temp;j = 1;while(j<n){min = rom[j-1], k = j-1;for( i=j; i<n; i++){if(rom[i] < min) min = rom[i], k = i;}if(k!=j-1){temp = min;rom[k] = rom[j-1];rom[j-1] = min;}j++;}}int main(){int rom[1000];int i=0, select, star;printf("请输入磁道的访问序列:(cntrl+z表示输入结束)\n");while(scanf("%d", &rom[i++])==1);i--;sort(rom, i);//选择排序while(1){printf("请选择:1.sstf算法 2.scan算法0.退出\n你的选择是:");scanf("%d", &select);if(select==0) break;printf("请输入起始位置:");scanf("%d", &star);if(select==1) sstf(star, rom, i);if(select==2) scan(star, rom, i);}return 0;}五、测试数据。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验七磁盘调度一、实验目的:磁盘是高速、大容量、旋转型、可直接存取的存储设备。
它作为计算机系统的辅助存储器,担负着繁重的输入输出工作,在现代计算机系统中往往同时会有若干个要求访问磁盘的输入输出要求。
系统可采用一种策略,尽可能按最佳次序执行访问磁盘的请求。
由于磁盘访问时间主要受寻道时间T的影响,为此需要采用合适的寻道算法,以降低寻道时间。
本实验要求模拟设计一个磁盘调度程序,观察调度程序的动态运行过程。
通过实验来理解和掌握磁盘调度的职能。
二、实验容:分别模拟如下电梯调度算法,对磁盘进行移臂操作:●先来先服务算法●最短寻道优先算法●电梯算法三、实验要求:1、假设磁盘只有一个盘面,并且磁盘是可移动头磁盘。
2、磁盘是可供多个进程共享的存储设备,但一个磁盘每个时刻只能为一个进程服务。
当有进程在访问某个磁盘时,其它想访问该磁盘的进程必须等待,直到磁盘一次工作结束。
当有多个进程提出输入输出请求而处于等待状态时,可用磁盘调度算法从若干个等待访问者中选择一个进程,让它访问磁盘。
为此设置“驱动调度”进程。
3、由于磁盘与处理器是并行工作的,所以当磁盘在为一个进程服务时,占有处理器的其它进程可以提出使用磁盘(这里我们只要求访问磁道),即动态申请访问磁道,为此设置“接受请求”进程。
4、为了模拟以上两个进程的执行,可以考虑使用随机数来确定二者的允许顺序,参考程序流程图。
5、“接受请求”进程建立一“进程请求I/O”表,指出等待访问磁盘的进程要求访问的磁道,表的格式如下:6、磁盘调度的功能是查“请求I/O”表,当有等待访问的进程时,按磁盘调度算法从中选择一个等待访问的进程,按其指定的要求访问磁道。
流程图中的“初始化”工作包括:初始化“请求I/O”表,设置当前移臂方向;当前磁道号。
并且假设程序运行前“请求I/O”表中已有若干进程(4~8个)申请访问相应磁道。
..四、程序流程图:五.参考程序代码:#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);//声明扫描函数SCANvoid 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; //f为磁道号print(head);cout<<"链表长度为:"<<c<<endl;cout<<"1、先来先服务算法FCFS"<<endl;cout<<"2、最短寻道时间优先算法SSTF"<<endl;cout<<"3、电梯调度算法(扫描算法SCAN)"<<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<<"你选择了:电梯调度算法(扫描算法SCAN)"<<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; //num为平均寻道长度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;..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;}}六.实验结果分析1. 假设磁盘访问序列: 89,138, 73,122,41,142,56,76,读写头起始位置:95分别按照下列调度算法安排磁头服务序列,并计算寻道距离。