操作系统课程设计报告 1.docx
《操作系统课程设计报告 1.docx》由会员分享,可在线阅读,更多相关《操作系统课程设计报告 1.docx(20页珍藏版)》请在冰豆网上搜索。
操作系统课程设计报告1
哈尔滨理工大学
课 程 设 计
(计算机操作系统)
题 目:
FIFO磁盘调度算法
班 级:
姓 名:
指导教师:
系主任:
2014年03月01日
目录
1FIFO磁盘调度算法课程设计1
1.1题目分析1
1.2数据结构1
1.3流程图1
1.4实现技术2
1.5设计结论和心得4
2Linux代码分析5
2.1功能说明15
2.2接口说明15
2.3局部数据结构15
2.4流程图16
2.5以实例说明运行过程16
1FIFO磁盘调度算法课程设计
1.1题目分析
本课程设计的目的是通过设计一个磁盘调度模拟系统,从而使磁盘调度算法更加形象化,容易使人理解,使磁盘调度的特点更简单明了,能使使用者加深对先来先服务磁盘调度算法的理解。
这是一种比较简单的磁盘调度算法。
它根据进程请求访问磁盘的先后次序进行调度。
此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。
此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。
1.2数据结构
1先来先服务算法模块:
voidFCFS(intarray[],intm)
输入磁道号,按先来先服务的策略输出磁盘请求序列,求平均寻道长度,输出移动平
均磁道数。
主要代码:
for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);}1.3流程图FIFO算法流程图:1.4实现技术为实现上述设计,采用C++语言,VS2008开发环境。具体采用的技术如下:(1)(2)实现步骤如下:(1)输入磁道序列、当前磁道号(2)FIFO磁盘调度(3)输出平均磁道数运行结果如下:1.5设计结论和心得通过课程设计得到如下结论:(1)本系统具有很强的健壮性,当输入错误数据类型时,系统提示用户输入的数据类型错误,让用户重新输入,保证系统的稳定性,不会因为用户的误操作而致使系统瘫痪;虽然是在dos状态下,但是本系统界面还是设计的比较漂亮的,具有比较好的交互性;对于软件中的重用代码,设计成一个函数,实现代码重用。本系统是在dos状态下进行编译执行的,没有图形化界面,可以设计出一个图形化界面,使用户操作更加简单,明了。有如下几点心得体会:(1)通过此次课程设计,我对操作系统的基础知识了解得更透彻了,同时对磁盘调度的四种算法——先来先服务算法(FCFS)、最短寻道时间优先算法(SSTF)、扫描算法(SCAN)、循环扫描算法(CSCAN)有了更深刻的理解和掌握,使我能够为磁盘调度选择适当的算法,提高CPU工作效率。设计过程中遇到的困难在老师和同学的帮助下顺利解决并通过了验收,我深刻认识到算法的逻辑性对程序的重要影响,算法的准确度对程序运行结果的重要影响,这对我以后在操作系统的学习中有极大帮助。 2Linux代码分析为了进一步了解操作系统内核,学习了Linux操作系统的进程同步程序,主要程序源代码如下:#include#include#include#include#definemaxsize1000/*********************判断输入数据是否有效**************************/intdecide(charstr[])//判断输入数据是否有效{inti=0;while(str[i]!='\0'){if(str[i]<'0'||str[i]>'9'){return0;break;}i++;}returni;}/******************将字符串转换成数字***********************/inttrans(charstr[],inta)//将字符串转换成数字{inti;intsum=0;for(i=0;i{sum=sum+(int)((str[i]-'0')*pow(10,a-i-1));}returnsum;}/*********************冒泡排序算法**************************/int*bubble(intcidao[],intm){inti,j;inttemp;for(i=0;ifor(j=i+1;j{if(cidao[i]>cidao[j]){temp=cidao[i];cidao[i]=cidao[j];cidao[j]=temp;}}cout<<"排序后的磁盘序列为:";for(i=0;i{cout<}cout<returncidao;}/*********************先来先服务调度算法**************************/voidFCFS(intcidao[],intm)//磁道号数组,个数为m{intnow;//当前磁道号intsum=0;//总寻道长度intj,i;inta;charstr[100];floatave;//平均寻道长度cout<<"磁盘请求序列为:";for(i=0;i{cout<}cout<cout<<"请输入当前的磁道号:";B:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoB;}elsenow=trans(str,a);//输入当前磁道号sum+=abs(cidao[0]-now);cout<<"磁盘扫描序列为:";for(i=0;i{cout<}for(i=0,j=1;j{sum+=abs(cidao[j]-cidao[i]);ave=(float)(sum)/(float)(m);}cout<cout<<"平均寻道长度:"<}/**********************最短寻道时间优先调度算法********************/voidSSTF(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";C:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoC;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;while((l>=0)&&(r{if((now-cidao[l])<=(cidao[r]-now))//选择与当前磁道最近的请求给予服务{cout<sum+=now-cidao[l];now=cidao[l];l=l-1;}else{cout<sum+=cidao[r]-now;now=cidao[r];r=r+1;}}if(l==-1)//磁头移动到序列的最小号,返回外侧扫描仍未扫描的磁道{for(j=r;j{cout<}sum+=cidao[m-1]-cidao[0];}else//磁头移动到序列的最大号,返回内侧扫描仍未扫描的磁道{for(j=l;j>=0;j--){cout<}sum+=cidao[m-1]-cidao[0];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/*****************************扫描调度算法*******************************/voidSCAN(intcidao[],intm)//先要给出当前磁道号和移动臂的移动方向{intk=1;intnow,l,r,d;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";D:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoD;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{while(cidao[k]{k++;}l=k-1;r=k;cout<<"请输入当前移动臂的移动的方向(1表示向外,0表示向内):";cin>>d;if(d==0)//选择移动臂方向向内,则先向内扫描{cout<<"磁盘扫描序列为:";for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*cidao[0]+cidao[m-1];}else//选择移动臂方向向外,则先向外扫描{cout<<"磁盘扫描序列为:";for(j=r;j{cout<}for(j=l;j>=0;j--)//磁头移动到最大号,则改变方向向内扫描未扫描的磁道{cout<}sum=-now-cidao[0]+2*cidao[m-1];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/************************循环扫描调度算法*****************************/voidCSCAN(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";E:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
{
sum+=abs(array[j]-array[i]);
ave=(float)(sum)/(float)(m);
}
1.3流程图
FIFO算法流程图:
1.4实现技术
为实现上述设计,采用C++语言,VS2008开发环境。
具体采用的技术如下:
(1)
(2)
实现步骤如下:
(1)输入磁道序列、当前磁道号
(2)FIFO磁盘调度
(3)输出平均磁道数
运行结果如下:
1.5设计结论和心得
通过课程设计得到如下结论:
(1)本系统具有很强的健壮性,当输入错误数据类型时,系统提示用户输入的数据类型错误,让用户重新输入,保证系统的稳定性,不会因为用户的误操作而致使系统瘫痪;虽然是在dos状态下,但是本系统界面还是设计的比较漂亮的,具有比较好的交互性;对于软件中的重用代码,设计成一个函数,实现代码重用。
本系统是在dos状态下进行编译执行的,没有图形化界面,可以设计出一个图形化界面,使用户操作更加简单,明了。
有如下几点心得体会:
(1)通过此次课程设计,我对操作系统的基础知识了解得更透彻了,同时对磁盘调度的四种算法——先来先服务算法(FCFS)、最短寻道时间优先算法(SSTF)、扫描算法(SCAN)、循环扫描算法(CSCAN)有了更深刻的理解和掌握,使我能够为磁盘调度选择适当的算法,提高CPU工作效率。
设计过程中遇到的困难在老师和同学的帮助下顺利解决并通过了验收,我深刻认识到算法的逻辑性对程序的重要影响,算法的准确度对程序运行结果的重要影响,这对我以后在操作系统的学习中有极大帮助。
2Linux代码分析
为了进一步了解操作系统内核,学习了Linux操作系统的进程同步程序,主要程序源代码如下:
#include
#definemaxsize1000
/*********************判断输入数据是否有效**************************/
intdecide(charstr[])//判断输入数据是否有效
inti=0;
while(str[i]!
='\0')
if(str[i]<'0'||str[i]>'9')
return0;
break;
i++;
returni;
/******************将字符串转换成数字***********************/
inttrans(charstr[],inta)//将字符串转换成数字
inti;
intsum=0;
for(i=0;i{sum=sum+(int)((str[i]-'0')*pow(10,a-i-1));}returnsum;}/*********************冒泡排序算法**************************/int*bubble(intcidao[],intm){inti,j;inttemp;for(i=0;ifor(j=i+1;j{if(cidao[i]>cidao[j]){temp=cidao[i];cidao[i]=cidao[j];cidao[j]=temp;}}cout<<"排序后的磁盘序列为:";for(i=0;i{cout<}cout<returncidao;}/*********************先来先服务调度算法**************************/voidFCFS(intcidao[],intm)//磁道号数组,个数为m{intnow;//当前磁道号intsum=0;//总寻道长度intj,i;inta;charstr[100];floatave;//平均寻道长度cout<<"磁盘请求序列为:";for(i=0;i{cout<}cout<cout<<"请输入当前的磁道号:";B:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoB;}elsenow=trans(str,a);//输入当前磁道号sum+=abs(cidao[0]-now);cout<<"磁盘扫描序列为:";for(i=0;i{cout<}for(i=0,j=1;j{sum+=abs(cidao[j]-cidao[i]);ave=(float)(sum)/(float)(m);}cout<cout<<"平均寻道长度:"<}/**********************最短寻道时间优先调度算法********************/voidSSTF(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";C:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoC;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;while((l>=0)&&(r{if((now-cidao[l])<=(cidao[r]-now))//选择与当前磁道最近的请求给予服务{cout<sum+=now-cidao[l];now=cidao[l];l=l-1;}else{cout<sum+=cidao[r]-now;now=cidao[r];r=r+1;}}if(l==-1)//磁头移动到序列的最小号,返回外侧扫描仍未扫描的磁道{for(j=r;j{cout<}sum+=cidao[m-1]-cidao[0];}else//磁头移动到序列的最大号,返回内侧扫描仍未扫描的磁道{for(j=l;j>=0;j--){cout<}sum+=cidao[m-1]-cidao[0];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/*****************************扫描调度算法*******************************/voidSCAN(intcidao[],intm)//先要给出当前磁道号和移动臂的移动方向{intk=1;intnow,l,r,d;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";D:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoD;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{while(cidao[k]{k++;}l=k-1;r=k;cout<<"请输入当前移动臂的移动的方向(1表示向外,0表示向内):";cin>>d;if(d==0)//选择移动臂方向向内,则先向内扫描{cout<<"磁盘扫描序列为:";for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*cidao[0]+cidao[m-1];}else//选择移动臂方向向外,则先向外扫描{cout<<"磁盘扫描序列为:";for(j=r;j{cout<}for(j=l;j>=0;j--)//磁头移动到最大号,则改变方向向内扫描未扫描的磁道{cout<}sum=-now-cidao[0]+2*cidao[m-1];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/************************循环扫描调度算法*****************************/voidCSCAN(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";E:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
sum=sum+(int)((str[i]-'0')*pow(10,a-i-1));
returnsum;
/*********************冒泡排序算法**************************/
int*bubble(intcidao[],intm)
inti,j;
inttemp;
for(i=0;ifor(j=i+1;j{if(cidao[i]>cidao[j]){temp=cidao[i];cidao[i]=cidao[j];cidao[j]=temp;}}cout<<"排序后的磁盘序列为:";for(i=0;i{cout<}cout<returncidao;}/*********************先来先服务调度算法**************************/voidFCFS(intcidao[],intm)//磁道号数组,个数为m{intnow;//当前磁道号intsum=0;//总寻道长度intj,i;inta;charstr[100];floatave;//平均寻道长度cout<<"磁盘请求序列为:";for(i=0;i{cout<}cout<cout<<"请输入当前的磁道号:";B:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoB;}elsenow=trans(str,a);//输入当前磁道号sum+=abs(cidao[0]-now);cout<<"磁盘扫描序列为:";for(i=0;i{cout<}for(i=0,j=1;j{sum+=abs(cidao[j]-cidao[i]);ave=(float)(sum)/(float)(m);}cout<cout<<"平均寻道长度:"<}/**********************最短寻道时间优先调度算法********************/voidSSTF(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";C:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoC;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;while((l>=0)&&(r{if((now-cidao[l])<=(cidao[r]-now))//选择与当前磁道最近的请求给予服务{cout<sum+=now-cidao[l];now=cidao[l];l=l-1;}else{cout<sum+=cidao[r]-now;now=cidao[r];r=r+1;}}if(l==-1)//磁头移动到序列的最小号,返回外侧扫描仍未扫描的磁道{for(j=r;j{cout<}sum+=cidao[m-1]-cidao[0];}else//磁头移动到序列的最大号,返回内侧扫描仍未扫描的磁道{for(j=l;j>=0;j--){cout<}sum+=cidao[m-1]-cidao[0];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/*****************************扫描调度算法*******************************/voidSCAN(intcidao[],intm)//先要给出当前磁道号和移动臂的移动方向{intk=1;intnow,l,r,d;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";D:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoD;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{while(cidao[k]{k++;}l=k-1;r=k;cout<<"请输入当前移动臂的移动的方向(1表示向外,0表示向内):";cin>>d;if(d==0)//选择移动臂方向向内,则先向内扫描{cout<<"磁盘扫描序列为:";for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*cidao[0]+cidao[m-1];}else//选择移动臂方向向外,则先向外扫描{cout<<"磁盘扫描序列为:";for(j=r;j{cout<}for(j=l;j>=0;j--)//磁头移动到最大号,则改变方向向内扫描未扫描的磁道{cout<}sum=-now-cidao[0]+2*cidao[m-1];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/************************循环扫描调度算法*****************************/voidCSCAN(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";E:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
for(j=i+1;j{if(cidao[i]>cidao[j]){temp=cidao[i];cidao[i]=cidao[j];cidao[j]=temp;}}cout<<"排序后的磁盘序列为:";for(i=0;i{cout<}cout<returncidao;}/*********************先来先服务调度算法**************************/voidFCFS(intcidao[],intm)//磁道号数组,个数为m{intnow;//当前磁道号intsum=0;//总寻道长度intj,i;inta;charstr[100];floatave;//平均寻道长度cout<<"磁盘请求序列为:";for(i=0;i{cout<}cout<cout<<"请输入当前的磁道号:";B:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoB;}elsenow=trans(str,a);//输入当前磁道号sum+=abs(cidao[0]-now);cout<<"磁盘扫描序列为:";for(i=0;i{cout<}for(i=0,j=1;j{sum+=abs(cidao[j]-cidao[i]);ave=(float)(sum)/(float)(m);}cout<cout<<"平均寻道长度:"<}/**********************最短寻道时间优先调度算法********************/voidSSTF(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";C:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoC;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;while((l>=0)&&(r{if((now-cidao[l])<=(cidao[r]-now))//选择与当前磁道最近的请求给予服务{cout<sum+=now-cidao[l];now=cidao[l];l=l-1;}else{cout<sum+=cidao[r]-now;now=cidao[r];r=r+1;}}if(l==-1)//磁头移动到序列的最小号,返回外侧扫描仍未扫描的磁道{for(j=r;j{cout<}sum+=cidao[m-1]-cidao[0];}else//磁头移动到序列的最大号,返回内侧扫描仍未扫描的磁道{for(j=l;j>=0;j--){cout<}sum+=cidao[m-1]-cidao[0];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/*****************************扫描调度算法*******************************/voidSCAN(intcidao[],intm)//先要给出当前磁道号和移动臂的移动方向{intk=1;intnow,l,r,d;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";D:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoD;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{while(cidao[k]{k++;}l=k-1;r=k;cout<<"请输入当前移动臂的移动的方向(1表示向外,0表示向内):";cin>>d;if(d==0)//选择移动臂方向向内,则先向内扫描{cout<<"磁盘扫描序列为:";for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*cidao[0]+cidao[m-1];}else//选择移动臂方向向外,则先向外扫描{cout<<"磁盘扫描序列为:";for(j=r;j{cout<}for(j=l;j>=0;j--)//磁头移动到最大号,则改变方向向内扫描未扫描的磁道{cout<}sum=-now-cidao[0]+2*cidao[m-1];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/************************循环扫描调度算法*****************************/voidCSCAN(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";E:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
if(cidao[i]>cidao[j])
temp=cidao[i];
cidao[i]=cidao[j];
cidao[j]=temp;
cout<<"排序后的磁盘序列为:
";
for(i=0;i{cout<}cout<returncidao;}/*********************先来先服务调度算法**************************/voidFCFS(intcidao[],intm)//磁道号数组,个数为m{intnow;//当前磁道号intsum=0;//总寻道长度intj,i;inta;charstr[100];floatave;//平均寻道长度cout<<"磁盘请求序列为:";for(i=0;i{cout<}cout<cout<<"请输入当前的磁道号:";B:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoB;}elsenow=trans(str,a);//输入当前磁道号sum+=abs(cidao[0]-now);cout<<"磁盘扫描序列为:";for(i=0;i{cout<}for(i=0,j=1;j{sum+=abs(cidao[j]-cidao[i]);ave=(float)(sum)/(float)(m);}cout<cout<<"平均寻道长度:"<}/**********************最短寻道时间优先调度算法********************/voidSSTF(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";C:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoC;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;while((l>=0)&&(r{if((now-cidao[l])<=(cidao[r]-now))//选择与当前磁道最近的请求给予服务{cout<sum+=now-cidao[l];now=cidao[l];l=l-1;}else{cout<sum+=cidao[r]-now;now=cidao[r];r=r+1;}}if(l==-1)//磁头移动到序列的最小号,返回外侧扫描仍未扫描的磁道{for(j=r;j{cout<}sum+=cidao[m-1]-cidao[0];}else//磁头移动到序列的最大号,返回内侧扫描仍未扫描的磁道{for(j=l;j>=0;j--){cout<}sum+=cidao[m-1]-cidao[0];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/*****************************扫描调度算法*******************************/voidSCAN(intcidao[],intm)//先要给出当前磁道号和移动臂的移动方向{intk=1;intnow,l,r,d;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";D:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoD;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{while(cidao[k]{k++;}l=k-1;r=k;cout<<"请输入当前移动臂的移动的方向(1表示向外,0表示向内):";cin>>d;if(d==0)//选择移动臂方向向内,则先向内扫描{cout<<"磁盘扫描序列为:";for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*cidao[0]+cidao[m-1];}else//选择移动臂方向向外,则先向外扫描{cout<<"磁盘扫描序列为:";for(j=r;j{cout<}for(j=l;j>=0;j--)//磁头移动到最大号,则改变方向向内扫描未扫描的磁道{cout<}sum=-now-cidao[0]+2*cidao[m-1];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/************************循环扫描调度算法*****************************/voidCSCAN(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";E:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
cout<}cout<returncidao;}/*********************先来先服务调度算法**************************/voidFCFS(intcidao[],intm)//磁道号数组,个数为m{intnow;//当前磁道号intsum=0;//总寻道长度intj,i;inta;charstr[100];floatave;//平均寻道长度cout<<"磁盘请求序列为:";for(i=0;i{cout<}cout<cout<<"请输入当前的磁道号:";B:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoB;}elsenow=trans(str,a);//输入当前磁道号sum+=abs(cidao[0]-now);cout<<"磁盘扫描序列为:";for(i=0;i{cout<}for(i=0,j=1;j{sum+=abs(cidao[j]-cidao[i]);ave=(float)(sum)/(float)(m);}cout<cout<<"平均寻道长度:"<}/**********************最短寻道时间优先调度算法********************/voidSSTF(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";C:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoC;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;while((l>=0)&&(r{if((now-cidao[l])<=(cidao[r]-now))//选择与当前磁道最近的请求给予服务{cout<sum+=now-cidao[l];now=cidao[l];l=l-1;}else{cout<sum+=cidao[r]-now;now=cidao[r];r=r+1;}}if(l==-1)//磁头移动到序列的最小号,返回外侧扫描仍未扫描的磁道{for(j=r;j{cout<}sum+=cidao[m-1]-cidao[0];}else//磁头移动到序列的最大号,返回内侧扫描仍未扫描的磁道{for(j=l;j>=0;j--){cout<}sum+=cidao[m-1]-cidao[0];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/*****************************扫描调度算法*******************************/voidSCAN(intcidao[],intm)//先要给出当前磁道号和移动臂的移动方向{intk=1;intnow,l,r,d;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";D:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoD;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{while(cidao[k]{k++;}l=k-1;r=k;cout<<"请输入当前移动臂的移动的方向(1表示向外,0表示向内):";cin>>d;if(d==0)//选择移动臂方向向内,则先向内扫描{cout<<"磁盘扫描序列为:";for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*cidao[0]+cidao[m-1];}else//选择移动臂方向向外,则先向外扫描{cout<<"磁盘扫描序列为:";for(j=r;j{cout<}for(j=l;j>=0;j--)//磁头移动到最大号,则改变方向向内扫描未扫描的磁道{cout<}sum=-now-cidao[0]+2*cidao[m-1];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/************************循环扫描调度算法*****************************/voidCSCAN(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";E:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
cout<returncidao;}/*********************先来先服务调度算法**************************/voidFCFS(intcidao[],intm)//磁道号数组,个数为m{intnow;//当前磁道号intsum=0;//总寻道长度intj,i;inta;charstr[100];floatave;//平均寻道长度cout<<"磁盘请求序列为:";for(i=0;i{cout<}cout<cout<<"请输入当前的磁道号:";B:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoB;}elsenow=trans(str,a);//输入当前磁道号sum+=abs(cidao[0]-now);cout<<"磁盘扫描序列为:";for(i=0;i{cout<}for(i=0,j=1;j{sum+=abs(cidao[j]-cidao[i]);ave=(float)(sum)/(float)(m);}cout<cout<<"平均寻道长度:"<}/**********************最短寻道时间优先调度算法********************/voidSSTF(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";C:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoC;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;while((l>=0)&&(r{if((now-cidao[l])<=(cidao[r]-now))//选择与当前磁道最近的请求给予服务{cout<sum+=now-cidao[l];now=cidao[l];l=l-1;}else{cout<sum+=cidao[r]-now;now=cidao[r];r=r+1;}}if(l==-1)//磁头移动到序列的最小号,返回外侧扫描仍未扫描的磁道{for(j=r;j{cout<}sum+=cidao[m-1]-cidao[0];}else//磁头移动到序列的最大号,返回内侧扫描仍未扫描的磁道{for(j=l;j>=0;j--){cout<}sum+=cidao[m-1]-cidao[0];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/*****************************扫描调度算法*******************************/voidSCAN(intcidao[],intm)//先要给出当前磁道号和移动臂的移动方向{intk=1;intnow,l,r,d;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";D:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoD;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{while(cidao[k]{k++;}l=k-1;r=k;cout<<"请输入当前移动臂的移动的方向(1表示向外,0表示向内):";cin>>d;if(d==0)//选择移动臂方向向内,则先向内扫描{cout<<"磁盘扫描序列为:";for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*cidao[0]+cidao[m-1];}else//选择移动臂方向向外,则先向外扫描{cout<<"磁盘扫描序列为:";for(j=r;j{cout<}for(j=l;j>=0;j--)//磁头移动到最大号,则改变方向向内扫描未扫描的磁道{cout<}sum=-now-cidao[0]+2*cidao[m-1];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/************************循环扫描调度算法*****************************/voidCSCAN(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";E:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
returncidao;
/*********************先来先服务调度算法**************************/
voidFCFS(intcidao[],intm)//磁道号数组,个数为m
intnow;//当前磁道号
intsum=0;//总寻道长度
intj,i;
inta;
charstr[100];
floatave;//平均寻道长度
cout<<"磁盘请求序列为:
for(i=0;i{cout<}cout<cout<<"请输入当前的磁道号:";B:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoB;}elsenow=trans(str,a);//输入当前磁道号sum+=abs(cidao[0]-now);cout<<"磁盘扫描序列为:";for(i=0;i{cout<}for(i=0,j=1;j{sum+=abs(cidao[j]-cidao[i]);ave=(float)(sum)/(float)(m);}cout<cout<<"平均寻道长度:"<}/**********************最短寻道时间优先调度算法********************/voidSSTF(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";C:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoC;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;while((l>=0)&&(r{if((now-cidao[l])<=(cidao[r]-now))//选择与当前磁道最近的请求给予服务{cout<sum+=now-cidao[l];now=cidao[l];l=l-1;}else{cout<sum+=cidao[r]-now;now=cidao[r];r=r+1;}}if(l==-1)//磁头移动到序列的最小号,返回外侧扫描仍未扫描的磁道{for(j=r;j{cout<}sum+=cidao[m-1]-cidao[0];}else//磁头移动到序列的最大号,返回内侧扫描仍未扫描的磁道{for(j=l;j>=0;j--){cout<}sum+=cidao[m-1]-cidao[0];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/*****************************扫描调度算法*******************************/voidSCAN(intcidao[],intm)//先要给出当前磁道号和移动臂的移动方向{intk=1;intnow,l,r,d;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";D:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoD;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{while(cidao[k]{k++;}l=k-1;r=k;cout<<"请输入当前移动臂的移动的方向(1表示向外,0表示向内):";cin>>d;if(d==0)//选择移动臂方向向内,则先向内扫描{cout<<"磁盘扫描序列为:";for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*cidao[0]+cidao[m-1];}else//选择移动臂方向向外,则先向外扫描{cout<<"磁盘扫描序列为:";for(j=r;j{cout<}for(j=l;j>=0;j--)//磁头移动到最大号,则改变方向向内扫描未扫描的磁道{cout<}sum=-now-cidao[0]+2*cidao[m-1];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/************************循环扫描调度算法*****************************/voidCSCAN(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";E:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
cout<}cout<cout<<"请输入当前的磁道号:";B:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoB;}elsenow=trans(str,a);//输入当前磁道号sum+=abs(cidao[0]-now);cout<<"磁盘扫描序列为:";for(i=0;i{cout<}for(i=0,j=1;j{sum+=abs(cidao[j]-cidao[i]);ave=(float)(sum)/(float)(m);}cout<cout<<"平均寻道长度:"<}/**********************最短寻道时间优先调度算法********************/voidSSTF(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";C:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoC;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;while((l>=0)&&(r{if((now-cidao[l])<=(cidao[r]-now))//选择与当前磁道最近的请求给予服务{cout<sum+=now-cidao[l];now=cidao[l];l=l-1;}else{cout<sum+=cidao[r]-now;now=cidao[r];r=r+1;}}if(l==-1)//磁头移动到序列的最小号,返回外侧扫描仍未扫描的磁道{for(j=r;j{cout<}sum+=cidao[m-1]-cidao[0];}else//磁头移动到序列的最大号,返回内侧扫描仍未扫描的磁道{for(j=l;j>=0;j--){cout<}sum+=cidao[m-1]-cidao[0];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/*****************************扫描调度算法*******************************/voidSCAN(intcidao[],intm)//先要给出当前磁道号和移动臂的移动方向{intk=1;intnow,l,r,d;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";D:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoD;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{while(cidao[k]{k++;}l=k-1;r=k;cout<<"请输入当前移动臂的移动的方向(1表示向外,0表示向内):";cin>>d;if(d==0)//选择移动臂方向向内,则先向内扫描{cout<<"磁盘扫描序列为:";for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*cidao[0]+cidao[m-1];}else//选择移动臂方向向外,则先向外扫描{cout<<"磁盘扫描序列为:";for(j=r;j{cout<}for(j=l;j>=0;j--)//磁头移动到最大号,则改变方向向内扫描未扫描的磁道{cout<}sum=-now-cidao[0]+2*cidao[m-1];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/************************循环扫描调度算法*****************************/voidCSCAN(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";E:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
cout<cout<<"请输入当前的磁道号:";B:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoB;}elsenow=trans(str,a);//输入当前磁道号sum+=abs(cidao[0]-now);cout<<"磁盘扫描序列为:";for(i=0;i{cout<}for(i=0,j=1;j{sum+=abs(cidao[j]-cidao[i]);ave=(float)(sum)/(float)(m);}cout<cout<<"平均寻道长度:"<}/**********************最短寻道时间优先调度算法********************/voidSSTF(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";C:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoC;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;while((l>=0)&&(r{if((now-cidao[l])<=(cidao[r]-now))//选择与当前磁道最近的请求给予服务{cout<sum+=now-cidao[l];now=cidao[l];l=l-1;}else{cout<sum+=cidao[r]-now;now=cidao[r];r=r+1;}}if(l==-1)//磁头移动到序列的最小号,返回外侧扫描仍未扫描的磁道{for(j=r;j{cout<}sum+=cidao[m-1]-cidao[0];}else//磁头移动到序列的最大号,返回内侧扫描仍未扫描的磁道{for(j=l;j>=0;j--){cout<}sum+=cidao[m-1]-cidao[0];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/*****************************扫描调度算法*******************************/voidSCAN(intcidao[],intm)//先要给出当前磁道号和移动臂的移动方向{intk=1;intnow,l,r,d;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";D:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoD;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{while(cidao[k]{k++;}l=k-1;r=k;cout<<"请输入当前移动臂的移动的方向(1表示向外,0表示向内):";cin>>d;if(d==0)//选择移动臂方向向内,则先向内扫描{cout<<"磁盘扫描序列为:";for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*cidao[0]+cidao[m-1];}else//选择移动臂方向向外,则先向外扫描{cout<<"磁盘扫描序列为:";for(j=r;j{cout<}for(j=l;j>=0;j--)//磁头移动到最大号,则改变方向向内扫描未扫描的磁道{cout<}sum=-now-cidao[0]+2*cidao[m-1];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/************************循环扫描调度算法*****************************/voidCSCAN(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";E:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
cout<<"请输入当前的磁道号:
B:
cin>>str;//对输入数据进行有效性判断
a=decide(str);
if(a==0)
cout<<"输入数据的类型错误,请重新输入!
"<gotoB;}elsenow=trans(str,a);//输入当前磁道号sum+=abs(cidao[0]-now);cout<<"磁盘扫描序列为:";for(i=0;i{cout<}for(i=0,j=1;j{sum+=abs(cidao[j]-cidao[i]);ave=(float)(sum)/(float)(m);}cout<cout<<"平均寻道长度:"<}/**********************最短寻道时间优先调度算法********************/voidSSTF(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";C:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoC;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;while((l>=0)&&(r{if((now-cidao[l])<=(cidao[r]-now))//选择与当前磁道最近的请求给予服务{cout<sum+=now-cidao[l];now=cidao[l];l=l-1;}else{cout<sum+=cidao[r]-now;now=cidao[r];r=r+1;}}if(l==-1)//磁头移动到序列的最小号,返回外侧扫描仍未扫描的磁道{for(j=r;j{cout<}sum+=cidao[m-1]-cidao[0];}else//磁头移动到序列的最大号,返回内侧扫描仍未扫描的磁道{for(j=l;j>=0;j--){cout<}sum+=cidao[m-1]-cidao[0];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/*****************************扫描调度算法*******************************/voidSCAN(intcidao[],intm)//先要给出当前磁道号和移动臂的移动方向{intk=1;intnow,l,r,d;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";D:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoD;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{while(cidao[k]{k++;}l=k-1;r=k;cout<<"请输入当前移动臂的移动的方向(1表示向外,0表示向内):";cin>>d;if(d==0)//选择移动臂方向向内,则先向内扫描{cout<<"磁盘扫描序列为:";for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*cidao[0]+cidao[m-1];}else//选择移动臂方向向外,则先向外扫描{cout<<"磁盘扫描序列为:";for(j=r;j{cout<}for(j=l;j>=0;j--)//磁头移动到最大号,则改变方向向内扫描未扫描的磁道{cout<}sum=-now-cidao[0]+2*cidao[m-1];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/************************循环扫描调度算法*****************************/voidCSCAN(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";E:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
gotoB;
else
now=trans(str,a);//输入当前磁道号
sum+=abs(cidao[0]-now);
cout<<"磁盘扫描序列为:
for(i=0;i{cout<}for(i=0,j=1;j{sum+=abs(cidao[j]-cidao[i]);ave=(float)(sum)/(float)(m);}cout<cout<<"平均寻道长度:"<}/**********************最短寻道时间优先调度算法********************/voidSSTF(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";C:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoC;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;while((l>=0)&&(r{if((now-cidao[l])<=(cidao[r]-now))//选择与当前磁道最近的请求给予服务{cout<sum+=now-cidao[l];now=cidao[l];l=l-1;}else{cout<sum+=cidao[r]-now;now=cidao[r];r=r+1;}}if(l==-1)//磁头移动到序列的最小号,返回外侧扫描仍未扫描的磁道{for(j=r;j{cout<}sum+=cidao[m-1]-cidao[0];}else//磁头移动到序列的最大号,返回内侧扫描仍未扫描的磁道{for(j=l;j>=0;j--){cout<}sum+=cidao[m-1]-cidao[0];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/*****************************扫描调度算法*******************************/voidSCAN(intcidao[],intm)//先要给出当前磁道号和移动臂的移动方向{intk=1;intnow,l,r,d;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";D:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoD;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{while(cidao[k]{k++;}l=k-1;r=k;cout<<"请输入当前移动臂的移动的方向(1表示向外,0表示向内):";cin>>d;if(d==0)//选择移动臂方向向内,则先向内扫描{cout<<"磁盘扫描序列为:";for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*cidao[0]+cidao[m-1];}else//选择移动臂方向向外,则先向外扫描{cout<<"磁盘扫描序列为:";for(j=r;j{cout<}for(j=l;j>=0;j--)//磁头移动到最大号,则改变方向向内扫描未扫描的磁道{cout<}sum=-now-cidao[0]+2*cidao[m-1];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/************************循环扫描调度算法*****************************/voidCSCAN(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";E:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
cout<}for(i=0,j=1;j{sum+=abs(cidao[j]-cidao[i]);ave=(float)(sum)/(float)(m);}cout<cout<<"平均寻道长度:"<}/**********************最短寻道时间优先调度算法********************/voidSSTF(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";C:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoC;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;while((l>=0)&&(r{if((now-cidao[l])<=(cidao[r]-now))//选择与当前磁道最近的请求给予服务{cout<sum+=now-cidao[l];now=cidao[l];l=l-1;}else{cout<sum+=cidao[r]-now;now=cidao[r];r=r+1;}}if(l==-1)//磁头移动到序列的最小号,返回外侧扫描仍未扫描的磁道{for(j=r;j{cout<}sum+=cidao[m-1]-cidao[0];}else//磁头移动到序列的最大号,返回内侧扫描仍未扫描的磁道{for(j=l;j>=0;j--){cout<}sum+=cidao[m-1]-cidao[0];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/*****************************扫描调度算法*******************************/voidSCAN(intcidao[],intm)//先要给出当前磁道号和移动臂的移动方向{intk=1;intnow,l,r,d;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";D:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoD;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{while(cidao[k]{k++;}l=k-1;r=k;cout<<"请输入当前移动臂的移动的方向(1表示向外,0表示向内):";cin>>d;if(d==0)//选择移动臂方向向内,则先向内扫描{cout<<"磁盘扫描序列为:";for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*cidao[0]+cidao[m-1];}else//选择移动臂方向向外,则先向外扫描{cout<<"磁盘扫描序列为:";for(j=r;j{cout<}for(j=l;j>=0;j--)//磁头移动到最大号,则改变方向向内扫描未扫描的磁道{cout<}sum=-now-cidao[0]+2*cidao[m-1];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/************************循环扫描调度算法*****************************/voidCSCAN(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";E:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
for(i=0,j=1;j{sum+=abs(cidao[j]-cidao[i]);ave=(float)(sum)/(float)(m);}cout<cout<<"平均寻道长度:"<}/**********************最短寻道时间优先调度算法********************/voidSSTF(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";C:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoC;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;while((l>=0)&&(r{if((now-cidao[l])<=(cidao[r]-now))//选择与当前磁道最近的请求给予服务{cout<sum+=now-cidao[l];now=cidao[l];l=l-1;}else{cout<sum+=cidao[r]-now;now=cidao[r];r=r+1;}}if(l==-1)//磁头移动到序列的最小号,返回外侧扫描仍未扫描的磁道{for(j=r;j{cout<}sum+=cidao[m-1]-cidao[0];}else//磁头移动到序列的最大号,返回内侧扫描仍未扫描的磁道{for(j=l;j>=0;j--){cout<}sum+=cidao[m-1]-cidao[0];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/*****************************扫描调度算法*******************************/voidSCAN(intcidao[],intm)//先要给出当前磁道号和移动臂的移动方向{intk=1;intnow,l,r,d;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";D:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoD;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{while(cidao[k]{k++;}l=k-1;r=k;cout<<"请输入当前移动臂的移动的方向(1表示向外,0表示向内):";cin>>d;if(d==0)//选择移动臂方向向内,则先向内扫描{cout<<"磁盘扫描序列为:";for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*cidao[0]+cidao[m-1];}else//选择移动臂方向向外,则先向外扫描{cout<<"磁盘扫描序列为:";for(j=r;j{cout<}for(j=l;j>=0;j--)//磁头移动到最大号,则改变方向向内扫描未扫描的磁道{cout<}sum=-now-cidao[0]+2*cidao[m-1];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/************************循环扫描调度算法*****************************/voidCSCAN(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";E:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
sum+=abs(cidao[j]-cidao[i]);
cout<cout<<"平均寻道长度:"<}/**********************最短寻道时间优先调度算法********************/voidSSTF(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";C:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoC;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;while((l>=0)&&(r{if((now-cidao[l])<=(cidao[r]-now))//选择与当前磁道最近的请求给予服务{cout<sum+=now-cidao[l];now=cidao[l];l=l-1;}else{cout<sum+=cidao[r]-now;now=cidao[r];r=r+1;}}if(l==-1)//磁头移动到序列的最小号,返回外侧扫描仍未扫描的磁道{for(j=r;j{cout<}sum+=cidao[m-1]-cidao[0];}else//磁头移动到序列的最大号,返回内侧扫描仍未扫描的磁道{for(j=l;j>=0;j--){cout<}sum+=cidao[m-1]-cidao[0];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/*****************************扫描调度算法*******************************/voidSCAN(intcidao[],intm)//先要给出当前磁道号和移动臂的移动方向{intk=1;intnow,l,r,d;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";D:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoD;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{while(cidao[k]{k++;}l=k-1;r=k;cout<<"请输入当前移动臂的移动的方向(1表示向外,0表示向内):";cin>>d;if(d==0)//选择移动臂方向向内,则先向内扫描{cout<<"磁盘扫描序列为:";for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*cidao[0]+cidao[m-1];}else//选择移动臂方向向外,则先向外扫描{cout<<"磁盘扫描序列为:";for(j=r;j{cout<}for(j=l;j>=0;j--)//磁头移动到最大号,则改变方向向内扫描未扫描的磁道{cout<}sum=-now-cidao[0]+2*cidao[m-1];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/************************循环扫描调度算法*****************************/voidCSCAN(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";E:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
cout<<"平均寻道长度:
"<}/**********************最短寻道时间优先调度算法********************/voidSSTF(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";C:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoC;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;while((l>=0)&&(r{if((now-cidao[l])<=(cidao[r]-now))//选择与当前磁道最近的请求给予服务{cout<sum+=now-cidao[l];now=cidao[l];l=l-1;}else{cout<sum+=cidao[r]-now;now=cidao[r];r=r+1;}}if(l==-1)//磁头移动到序列的最小号,返回外侧扫描仍未扫描的磁道{for(j=r;j{cout<}sum+=cidao[m-1]-cidao[0];}else//磁头移动到序列的最大号,返回内侧扫描仍未扫描的磁道{for(j=l;j>=0;j--){cout<}sum+=cidao[m-1]-cidao[0];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/*****************************扫描调度算法*******************************/voidSCAN(intcidao[],intm)//先要给出当前磁道号和移动臂的移动方向{intk=1;intnow,l,r,d;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";D:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoD;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{while(cidao[k]{k++;}l=k-1;r=k;cout<<"请输入当前移动臂的移动的方向(1表示向外,0表示向内):";cin>>d;if(d==0)//选择移动臂方向向内,则先向内扫描{cout<<"磁盘扫描序列为:";for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*cidao[0]+cidao[m-1];}else//选择移动臂方向向外,则先向外扫描{cout<<"磁盘扫描序列为:";for(j=r;j{cout<}for(j=l;j>=0;j--)//磁头移动到最大号,则改变方向向内扫描未扫描的磁道{cout<}sum=-now-cidao[0]+2*cidao[m-1];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/************************循环扫描调度算法*****************************/voidCSCAN(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";E:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
/**********************最短寻道时间优先调度算法********************/
voidSSTF(intcidao[],intm)
intk=1;
intnow,l,r;
inti,j,sum=0;
floatave;
cidao=bubble(cidao,m);//调用冒泡排序算法排序
C:
"<gotoC;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;while((l>=0)&&(r{if((now-cidao[l])<=(cidao[r]-now))//选择与当前磁道最近的请求给予服务{cout<sum+=now-cidao[l];now=cidao[l];l=l-1;}else{cout<sum+=cidao[r]-now;now=cidao[r];r=r+1;}}if(l==-1)//磁头移动到序列的最小号,返回外侧扫描仍未扫描的磁道{for(j=r;j{cout<}sum+=cidao[m-1]-cidao[0];}else//磁头移动到序列的最大号,返回内侧扫描仍未扫描的磁道{for(j=l;j>=0;j--){cout<}sum+=cidao[m-1]-cidao[0];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/*****************************扫描调度算法*******************************/voidSCAN(intcidao[],intm)//先要给出当前磁道号和移动臂的移动方向{intk=1;intnow,l,r,d;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";D:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoD;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{while(cidao[k]{k++;}l=k-1;r=k;cout<<"请输入当前移动臂的移动的方向(1表示向外,0表示向内):";cin>>d;if(d==0)//选择移动臂方向向内,则先向内扫描{cout<<"磁盘扫描序列为:";for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*cidao[0]+cidao[m-1];}else//选择移动臂方向向外,则先向外扫描{cout<<"磁盘扫描序列为:";for(j=r;j{cout<}for(j=l;j>=0;j--)//磁头移动到最大号,则改变方向向内扫描未扫描的磁道{cout<}sum=-now-cidao[0]+2*cidao[m-1];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/************************循环扫描调度算法*****************************/voidCSCAN(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";E:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
gotoC;
if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务
for(i=m-1;i>=0;i--)
cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;while((l>=0)&&(r{if((now-cidao[l])<=(cidao[r]-now))//选择与当前磁道最近的请求给予服务{cout<sum+=now-cidao[l];now=cidao[l];l=l-1;}else{cout<sum+=cidao[r]-now;now=cidao[r];r=r+1;}}if(l==-1)//磁头移动到序列的最小号,返回外侧扫描仍未扫描的磁道{for(j=r;j{cout<}sum+=cidao[m-1]-cidao[0];}else//磁头移动到序列的最大号,返回内侧扫描仍未扫描的磁道{for(j=l;j>=0;j--){cout<}sum+=cidao[m-1]-cidao[0];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/*****************************扫描调度算法*******************************/voidSCAN(intcidao[],intm)//先要给出当前磁道号和移动臂的移动方向{intk=1;intnow,l,r,d;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";D:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoD;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{while(cidao[k]{k++;}l=k-1;r=k;cout<<"请输入当前移动臂的移动的方向(1表示向外,0表示向内):";cin>>d;if(d==0)//选择移动臂方向向内,则先向内扫描{cout<<"磁盘扫描序列为:";for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*cidao[0]+cidao[m-1];}else//选择移动臂方向向外,则先向外扫描{cout<<"磁盘扫描序列为:";for(j=r;j{cout<}for(j=l;j>=0;j--)//磁头移动到最大号,则改变方向向内扫描未扫描的磁道{cout<}sum=-now-cidao[0]+2*cidao[m-1];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/************************循环扫描调度算法*****************************/voidCSCAN(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";E:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
sum=now-cidao[0];
if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务
for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;while((l>=0)&&(r{if((now-cidao[l])<=(cidao[r]-now))//选择与当前磁道最近的请求给予服务{cout<sum+=now-cidao[l];now=cidao[l];l=l-1;}else{cout<sum+=cidao[r]-now;now=cidao[r];r=r+1;}}if(l==-1)//磁头移动到序列的最小号,返回外侧扫描仍未扫描的磁道{for(j=r;j{cout<}sum+=cidao[m-1]-cidao[0];}else//磁头移动到序列的最大号,返回内侧扫描仍未扫描的磁道{for(j=l;j>=0;j--){cout<}sum+=cidao[m-1]-cidao[0];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/*****************************扫描调度算法*******************************/voidSCAN(intcidao[],intm)//先要给出当前磁道号和移动臂的移动方向{intk=1;intnow,l,r,d;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";D:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoD;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{while(cidao[k]{k++;}l=k-1;r=k;cout<<"请输入当前移动臂的移动的方向(1表示向外,0表示向内):";cin>>d;if(d==0)//选择移动臂方向向内,则先向内扫描{cout<<"磁盘扫描序列为:";for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*cidao[0]+cidao[m-1];}else//选择移动臂方向向外,则先向外扫描{cout<<"磁盘扫描序列为:";for(j=r;j{cout<}for(j=l;j>=0;j--)//磁头移动到最大号,则改变方向向内扫描未扫描的磁道{cout<}sum=-now-cidao[0]+2*cidao[m-1];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/************************循环扫描调度算法*****************************/voidCSCAN(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";E:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
cout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;while((l>=0)&&(r{if((now-cidao[l])<=(cidao[r]-now))//选择与当前磁道最近的请求给予服务{cout<sum+=now-cidao[l];now=cidao[l];l=l-1;}else{cout<sum+=cidao[r]-now;now=cidao[r];r=r+1;}}if(l==-1)//磁头移动到序列的最小号,返回外侧扫描仍未扫描的磁道{for(j=r;j{cout<}sum+=cidao[m-1]-cidao[0];}else//磁头移动到序列的最大号,返回内侧扫描仍未扫描的磁道{for(j=l;j>=0;j--){cout<}sum+=cidao[m-1]-cidao[0];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/*****************************扫描调度算法*******************************/voidSCAN(intcidao[],intm)//先要给出当前磁道号和移动臂的移动方向{intk=1;intnow,l,r,d;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";D:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoD;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{while(cidao[k]{k++;}l=k-1;r=k;cout<<"请输入当前移动臂的移动的方向(1表示向外,0表示向内):";cin>>d;if(d==0)//选择移动臂方向向内,则先向内扫描{cout<<"磁盘扫描序列为:";for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*cidao[0]+cidao[m-1];}else//选择移动臂方向向外,则先向外扫描{cout<<"磁盘扫描序列为:";for(j=r;j{cout<}for(j=l;j>=0;j--)//磁头移动到最大号,则改变方向向内扫描未扫描的磁道{cout<}sum=-now-cidao[0]+2*cidao[m-1];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/************************循环扫描调度算法*****************************/voidCSCAN(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";E:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
sum=cidao[m-1]-now;
if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;while((l>=0)&&(r{if((now-cidao[l])<=(cidao[r]-now))//选择与当前磁道最近的请求给予服务{cout<sum+=now-cidao[l];now=cidao[l];l=l-1;}else{cout<sum+=cidao[r]-now;now=cidao[r];r=r+1;}}if(l==-1)//磁头移动到序列的最小号,返回外侧扫描仍未扫描的磁道{for(j=r;j{cout<}sum+=cidao[m-1]-cidao[0];}else//磁头移动到序列的最大号,返回内侧扫描仍未扫描的磁道{for(j=l;j>=0;j--){cout<}sum+=cidao[m-1]-cidao[0];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/*****************************扫描调度算法*******************************/voidSCAN(intcidao[],intm)//先要给出当前磁道号和移动臂的移动方向{intk=1;intnow,l,r,d;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";D:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoD;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{while(cidao[k]{k++;}l=k-1;r=k;cout<<"请输入当前移动臂的移动的方向(1表示向外,0表示向内):";cin>>d;if(d==0)//选择移动臂方向向内,则先向内扫描{cout<<"磁盘扫描序列为:";for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*cidao[0]+cidao[m-1];}else//选择移动臂方向向外,则先向外扫描{cout<<"磁盘扫描序列为:";for(j=r;j{cout<}for(j=l;j>=0;j--)//磁头移动到最大号,则改变方向向内扫描未扫描的磁道{cout<}sum=-now-cidao[0]+2*cidao[m-1];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/************************循环扫描调度算法*****************************/voidCSCAN(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";E:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
while(cidao[k]{k++;}l=k-1;r=k;while((l>=0)&&(r{if((now-cidao[l])<=(cidao[r]-now))//选择与当前磁道最近的请求给予服务{cout<sum+=now-cidao[l];now=cidao[l];l=l-1;}else{cout<sum+=cidao[r]-now;now=cidao[r];r=r+1;}}if(l==-1)//磁头移动到序列的最小号,返回外侧扫描仍未扫描的磁道{for(j=r;j{cout<}sum+=cidao[m-1]-cidao[0];}else//磁头移动到序列的最大号,返回内侧扫描仍未扫描的磁道{for(j=l;j>=0;j--){cout<}sum+=cidao[m-1]-cidao[0];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/*****************************扫描调度算法*******************************/voidSCAN(intcidao[],intm)//先要给出当前磁道号和移动臂的移动方向{intk=1;intnow,l,r,d;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";D:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoD;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{while(cidao[k]{k++;}l=k-1;r=k;cout<<"请输入当前移动臂的移动的方向(1表示向外,0表示向内):";cin>>d;if(d==0)//选择移动臂方向向内,则先向内扫描{cout<<"磁盘扫描序列为:";for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*cidao[0]+cidao[m-1];}else//选择移动臂方向向外,则先向外扫描{cout<<"磁盘扫描序列为:";for(j=r;j{cout<}for(j=l;j>=0;j--)//磁头移动到最大号,则改变方向向内扫描未扫描的磁道{cout<}sum=-now-cidao[0]+2*cidao[m-1];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/************************循环扫描调度算法*****************************/voidCSCAN(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";E:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
k++;
l=k-1;
r=k;
while((l>=0)&&(r{if((now-cidao[l])<=(cidao[r]-now))//选择与当前磁道最近的请求给予服务{cout<sum+=now-cidao[l];now=cidao[l];l=l-1;}else{cout<sum+=cidao[r]-now;now=cidao[r];r=r+1;}}if(l==-1)//磁头移动到序列的最小号,返回外侧扫描仍未扫描的磁道{for(j=r;j{cout<}sum+=cidao[m-1]-cidao[0];}else//磁头移动到序列的最大号,返回内侧扫描仍未扫描的磁道{for(j=l;j>=0;j--){cout<}sum+=cidao[m-1]-cidao[0];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/*****************************扫描调度算法*******************************/voidSCAN(intcidao[],intm)//先要给出当前磁道号和移动臂的移动方向{intk=1;intnow,l,r,d;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";D:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoD;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{while(cidao[k]{k++;}l=k-1;r=k;cout<<"请输入当前移动臂的移动的方向(1表示向外,0表示向内):";cin>>d;if(d==0)//选择移动臂方向向内,则先向内扫描{cout<<"磁盘扫描序列为:";for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*cidao[0]+cidao[m-1];}else//选择移动臂方向向外,则先向外扫描{cout<<"磁盘扫描序列为:";for(j=r;j{cout<}for(j=l;j>=0;j--)//磁头移动到最大号,则改变方向向内扫描未扫描的磁道{cout<}sum=-now-cidao[0]+2*cidao[m-1];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/************************循环扫描调度算法*****************************/voidCSCAN(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";E:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
if((now-cidao[l])<=(cidao[r]-now))//选择与当前磁道最近的请求给予服务
cout<sum+=now-cidao[l];now=cidao[l];l=l-1;}else{cout<sum+=cidao[r]-now;now=cidao[r];r=r+1;}}if(l==-1)//磁头移动到序列的最小号,返回外侧扫描仍未扫描的磁道{for(j=r;j{cout<}sum+=cidao[m-1]-cidao[0];}else//磁头移动到序列的最大号,返回内侧扫描仍未扫描的磁道{for(j=l;j>=0;j--){cout<}sum+=cidao[m-1]-cidao[0];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/*****************************扫描调度算法*******************************/voidSCAN(intcidao[],intm)//先要给出当前磁道号和移动臂的移动方向{intk=1;intnow,l,r,d;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";D:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoD;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{while(cidao[k]{k++;}l=k-1;r=k;cout<<"请输入当前移动臂的移动的方向(1表示向外,0表示向内):";cin>>d;if(d==0)//选择移动臂方向向内,则先向内扫描{cout<<"磁盘扫描序列为:";for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*cidao[0]+cidao[m-1];}else//选择移动臂方向向外,则先向外扫描{cout<<"磁盘扫描序列为:";for(j=r;j{cout<}for(j=l;j>=0;j--)//磁头移动到最大号,则改变方向向内扫描未扫描的磁道{cout<}sum=-now-cidao[0]+2*cidao[m-1];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/************************循环扫描调度算法*****************************/voidCSCAN(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";E:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
sum+=now-cidao[l];
now=cidao[l];
l=l-1;
cout<sum+=cidao[r]-now;now=cidao[r];r=r+1;}}if(l==-1)//磁头移动到序列的最小号,返回外侧扫描仍未扫描的磁道{for(j=r;j{cout<}sum+=cidao[m-1]-cidao[0];}else//磁头移动到序列的最大号,返回内侧扫描仍未扫描的磁道{for(j=l;j>=0;j--){cout<}sum+=cidao[m-1]-cidao[0];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/*****************************扫描调度算法*******************************/voidSCAN(intcidao[],intm)//先要给出当前磁道号和移动臂的移动方向{intk=1;intnow,l,r,d;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";D:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoD;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{while(cidao[k]{k++;}l=k-1;r=k;cout<<"请输入当前移动臂的移动的方向(1表示向外,0表示向内):";cin>>d;if(d==0)//选择移动臂方向向内,则先向内扫描{cout<<"磁盘扫描序列为:";for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*cidao[0]+cidao[m-1];}else//选择移动臂方向向外,则先向外扫描{cout<<"磁盘扫描序列为:";for(j=r;j{cout<}for(j=l;j>=0;j--)//磁头移动到最大号,则改变方向向内扫描未扫描的磁道{cout<}sum=-now-cidao[0]+2*cidao[m-1];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/************************循环扫描调度算法*****************************/voidCSCAN(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";E:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
sum+=cidao[r]-now;
now=cidao[r];
r=r+1;
if(l==-1)//磁头移动到序列的最小号,返回外侧扫描仍未扫描的磁道
for(j=r;j{cout<}sum+=cidao[m-1]-cidao[0];}else//磁头移动到序列的最大号,返回内侧扫描仍未扫描的磁道{for(j=l;j>=0;j--){cout<}sum+=cidao[m-1]-cidao[0];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/*****************************扫描调度算法*******************************/voidSCAN(intcidao[],intm)//先要给出当前磁道号和移动臂的移动方向{intk=1;intnow,l,r,d;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";D:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoD;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{while(cidao[k]{k++;}l=k-1;r=k;cout<<"请输入当前移动臂的移动的方向(1表示向外,0表示向内):";cin>>d;if(d==0)//选择移动臂方向向内,则先向内扫描{cout<<"磁盘扫描序列为:";for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*cidao[0]+cidao[m-1];}else//选择移动臂方向向外,则先向外扫描{cout<<"磁盘扫描序列为:";for(j=r;j{cout<}for(j=l;j>=0;j--)//磁头移动到最大号,则改变方向向内扫描未扫描的磁道{cout<}sum=-now-cidao[0]+2*cidao[m-1];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/************************循环扫描调度算法*****************************/voidCSCAN(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";E:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
cout<}sum+=cidao[m-1]-cidao[0];}else//磁头移动到序列的最大号,返回内侧扫描仍未扫描的磁道{for(j=l;j>=0;j--){cout<}sum+=cidao[m-1]-cidao[0];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/*****************************扫描调度算法*******************************/voidSCAN(intcidao[],intm)//先要给出当前磁道号和移动臂的移动方向{intk=1;intnow,l,r,d;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";D:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoD;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{while(cidao[k]{k++;}l=k-1;r=k;cout<<"请输入当前移动臂的移动的方向(1表示向外,0表示向内):";cin>>d;if(d==0)//选择移动臂方向向内,则先向内扫描{cout<<"磁盘扫描序列为:";for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*cidao[0]+cidao[m-1];}else//选择移动臂方向向外,则先向外扫描{cout<<"磁盘扫描序列为:";for(j=r;j{cout<}for(j=l;j>=0;j--)//磁头移动到最大号,则改变方向向内扫描未扫描的磁道{cout<}sum=-now-cidao[0]+2*cidao[m-1];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/************************循环扫描调度算法*****************************/voidCSCAN(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";E:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
sum+=cidao[m-1]-cidao[0];
else//磁头移动到序列的最大号,返回内侧扫描仍未扫描的磁道
for(j=l;j>=0;j--)
cout<}sum+=cidao[m-1]-cidao[0];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/*****************************扫描调度算法*******************************/voidSCAN(intcidao[],intm)//先要给出当前磁道号和移动臂的移动方向{intk=1;intnow,l,r,d;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";D:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoD;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{while(cidao[k]{k++;}l=k-1;r=k;cout<<"请输入当前移动臂的移动的方向(1表示向外,0表示向内):";cin>>d;if(d==0)//选择移动臂方向向内,则先向内扫描{cout<<"磁盘扫描序列为:";for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*cidao[0]+cidao[m-1];}else//选择移动臂方向向外,则先向外扫描{cout<<"磁盘扫描序列为:";for(j=r;j{cout<}for(j=l;j>=0;j--)//磁头移动到最大号,则改变方向向内扫描未扫描的磁道{cout<}sum=-now-cidao[0]+2*cidao[m-1];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/************************循环扫描调度算法*****************************/voidCSCAN(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";E:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
cout<cout<<"平均寻道长度:"<}/*****************************扫描调度算法*******************************/voidSCAN(intcidao[],intm)//先要给出当前磁道号和移动臂的移动方向{intk=1;intnow,l,r,d;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";D:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoD;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{while(cidao[k]{k++;}l=k-1;r=k;cout<<"请输入当前移动臂的移动的方向(1表示向外,0表示向内):";cin>>d;if(d==0)//选择移动臂方向向内,则先向内扫描{cout<<"磁盘扫描序列为:";for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*cidao[0]+cidao[m-1];}else//选择移动臂方向向外,则先向外扫描{cout<<"磁盘扫描序列为:";for(j=r;j{cout<}for(j=l;j>=0;j--)//磁头移动到最大号,则改变方向向内扫描未扫描的磁道{cout<}sum=-now-cidao[0]+2*cidao[m-1];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/************************循环扫描调度算法*****************************/voidCSCAN(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";E:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
"<}/*****************************扫描调度算法*******************************/voidSCAN(intcidao[],intm)//先要给出当前磁道号和移动臂的移动方向{intk=1;intnow,l,r,d;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";D:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoD;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{while(cidao[k]{k++;}l=k-1;r=k;cout<<"请输入当前移动臂的移动的方向(1表示向外,0表示向内):";cin>>d;if(d==0)//选择移动臂方向向内,则先向内扫描{cout<<"磁盘扫描序列为:";for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*cidao[0]+cidao[m-1];}else//选择移动臂方向向外,则先向外扫描{cout<<"磁盘扫描序列为:";for(j=r;j{cout<}for(j=l;j>=0;j--)//磁头移动到最大号,则改变方向向内扫描未扫描的磁道{cout<}sum=-now-cidao[0]+2*cidao[m-1];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/************************循环扫描调度算法*****************************/voidCSCAN(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";E:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
/*****************************扫描调度算法*******************************/
voidSCAN(intcidao[],intm)//先要给出当前磁道号和移动臂的移动方向
intnow,l,r,d;
D:
"<gotoD;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=m-1;i>=0;i--)cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{while(cidao[k]{k++;}l=k-1;r=k;cout<<"请输入当前移动臂的移动的方向(1表示向外,0表示向内):";cin>>d;if(d==0)//选择移动臂方向向内,则先向内扫描{cout<<"磁盘扫描序列为:";for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*cidao[0]+cidao[m-1];}else//选择移动臂方向向外,则先向外扫描{cout<<"磁盘扫描序列为:";for(j=r;j{cout<}for(j=l;j>=0;j--)//磁头移动到最大号,则改变方向向内扫描未扫描的磁道{cout<}sum=-now-cidao[0]+2*cidao[m-1];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/************************循环扫描调度算法*****************************/voidCSCAN(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";E:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
gotoD;
if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接由外向内依次给予各请求服务,此情况同最短寻道优先
cout<sum=now-cidao[0];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{while(cidao[k]{k++;}l=k-1;r=k;cout<<"请输入当前移动臂的移动的方向(1表示向外,0表示向内):";cin>>d;if(d==0)//选择移动臂方向向内,则先向内扫描{cout<<"磁盘扫描序列为:";for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*cidao[0]+cidao[m-1];}else//选择移动臂方向向外,则先向外扫描{cout<<"磁盘扫描序列为:";for(j=r;j{cout<}for(j=l;j>=0;j--)//磁头移动到最大号,则改变方向向内扫描未扫描的磁道{cout<}sum=-now-cidao[0]+2*cidao[m-1];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/************************循环扫描调度算法*****************************/voidCSCAN(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";E:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先
for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{while(cidao[k]{k++;}l=k-1;r=k;cout<<"请输入当前移动臂的移动的方向(1表示向外,0表示向内):";cin>>d;if(d==0)//选择移动臂方向向内,则先向内扫描{cout<<"磁盘扫描序列为:";for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*cidao[0]+cidao[m-1];}else//选择移动臂方向向外,则先向外扫描{cout<<"磁盘扫描序列为:";for(j=r;j{cout<}for(j=l;j>=0;j--)//磁头移动到最大号,则改变方向向内扫描未扫描的磁道{cout<}sum=-now-cidao[0]+2*cidao[m-1];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/************************循环扫描调度算法*****************************/voidCSCAN(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";E:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
cout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{while(cidao[k]{k++;}l=k-1;r=k;cout<<"请输入当前移动臂的移动的方向(1表示向外,0表示向内):";cin>>d;if(d==0)//选择移动臂方向向内,则先向内扫描{cout<<"磁盘扫描序列为:";for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*cidao[0]+cidao[m-1];}else//选择移动臂方向向外,则先向外扫描{cout<<"磁盘扫描序列为:";for(j=r;j{cout<}for(j=l;j>=0;j--)//磁头移动到最大号,则改变方向向内扫描未扫描的磁道{cout<}sum=-now-cidao[0]+2*cidao[m-1];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/************************循环扫描调度算法*****************************/voidCSCAN(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";E:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
if(now>cidao[0]&&now{while(cidao[k]{k++;}l=k-1;r=k;cout<<"请输入当前移动臂的移动的方向(1表示向外,0表示向内):";cin>>d;if(d==0)//选择移动臂方向向内,则先向内扫描{cout<<"磁盘扫描序列为:";for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*cidao[0]+cidao[m-1];}else//选择移动臂方向向外,则先向外扫描{cout<<"磁盘扫描序列为:";for(j=r;j{cout<}for(j=l;j>=0;j--)//磁头移动到最大号,则改变方向向内扫描未扫描的磁道{cout<}sum=-now-cidao[0]+2*cidao[m-1];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/************************循环扫描调度算法*****************************/voidCSCAN(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";E:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
while(cidao[k]{k++;}l=k-1;r=k;cout<<"请输入当前移动臂的移动的方向(1表示向外,0表示向内):";cin>>d;if(d==0)//选择移动臂方向向内,则先向内扫描{cout<<"磁盘扫描序列为:";for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*cidao[0]+cidao[m-1];}else//选择移动臂方向向外,则先向外扫描{cout<<"磁盘扫描序列为:";for(j=r;j{cout<}for(j=l;j>=0;j--)//磁头移动到最大号,则改变方向向内扫描未扫描的磁道{cout<}sum=-now-cidao[0]+2*cidao[m-1];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/************************循环扫描调度算法*****************************/voidCSCAN(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";E:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
cout<<"请输入当前移动臂的移动的方向(1表示向外,0表示向内):
cin>>d;
if(d==0)//选择移动臂方向向内,则先向内扫描
cout<}for(j=r;j{cout<}sum=now-2*cidao[0]+cidao[m-1];}else//选择移动臂方向向外,则先向外扫描{cout<<"磁盘扫描序列为:";for(j=r;j{cout<}for(j=l;j>=0;j--)//磁头移动到最大号,则改变方向向内扫描未扫描的磁道{cout<}sum=-now-cidao[0]+2*cidao[m-1];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/************************循环扫描调度算法*****************************/voidCSCAN(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";E:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
for(j=r;j{cout<}sum=now-2*cidao[0]+cidao[m-1];}else//选择移动臂方向向外,则先向外扫描{cout<<"磁盘扫描序列为:";for(j=r;j{cout<}for(j=l;j>=0;j--)//磁头移动到最大号,则改变方向向内扫描未扫描的磁道{cout<}sum=-now-cidao[0]+2*cidao[m-1];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/************************循环扫描调度算法*****************************/voidCSCAN(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";E:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
cout<}sum=now-2*cidao[0]+cidao[m-1];}else//选择移动臂方向向外,则先向外扫描{cout<<"磁盘扫描序列为:";for(j=r;j{cout<}for(j=l;j>=0;j--)//磁头移动到最大号,则改变方向向内扫描未扫描的磁道{cout<}sum=-now-cidao[0]+2*cidao[m-1];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/************************循环扫描调度算法*****************************/voidCSCAN(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";E:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
sum=now-2*cidao[0]+cidao[m-1];
else//选择移动臂方向向外,则先向外扫描
for(j=r;j{cout<}for(j=l;j>=0;j--)//磁头移动到最大号,则改变方向向内扫描未扫描的磁道{cout<}sum=-now-cidao[0]+2*cidao[m-1];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/************************循环扫描调度算法*****************************/voidCSCAN(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";E:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
cout<}for(j=l;j>=0;j--)//磁头移动到最大号,则改变方向向内扫描未扫描的磁道{cout<}sum=-now-cidao[0]+2*cidao[m-1];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/************************循环扫描调度算法*****************************/voidCSCAN(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";E:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
for(j=l;j>=0;j--)//磁头移动到最大号,则改变方向向内扫描未扫描的磁道
cout<}sum=-now-cidao[0]+2*cidao[m-1];}}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}/************************循环扫描调度算法*****************************/voidCSCAN(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";E:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
sum=-now-cidao[0]+2*cidao[m-1];
cout<cout<<"平均寻道长度:"<}/************************循环扫描调度算法*****************************/voidCSCAN(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";E:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
"<}/************************循环扫描调度算法*****************************/voidCSCAN(intcidao[],intm){intk=1;intnow,l,r;inti,j,sum=0;inta;charstr[100];floatave;cidao=bubble(cidao,m);//调用冒泡排序算法排序cout<<"请输入当前的磁道号:";E:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
/************************循环扫描调度算法*****************************/
voidCSCAN(intcidao[],intm)
E:
"<gotoE;}elsenow=trans(str,a);//输入当前磁道号if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
gotoE;
if(cidao[m-1]<=now)//若当前磁道号大于请求序列中最大者,则直接将移动臂移动到最小号磁道依次向外给予各请求服务
for(i=0;icout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
cout<sum=now-2*cidao[0]+cidao[m-1];}if(cidao[0]>=now)//若当前磁道号小于请求序列中最小者,则直接由内向外依次给予各请求服务,此情况同最短寻道优先{cout<<"磁盘扫描序列为:";for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
for(i=0;icout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
cout<sum=cidao[m-1]-now;}if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
if(now>cidao[0]&&now{cout<<"磁盘扫描序列为:";while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
while(cidao[k]{k++;}l=k-1;r=k;for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
for(j=r;j{cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
cout<}for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
for(j=0;j{cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
cout<}sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];}ave=(float)(sum)/(float)(m);cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
sum=2*cidao[m-1]+cidao[l]-now-2*cidao[0];
cout<cout<<"平均寻道长度:"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
"<}voidmain(){inta;intc;//菜单项intcidao[maxsize];inti=0,count;charstr[100];cout<<"请输入磁道序列(0结束):"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
voidmain()
intc;//菜单项
intcidao[maxsize];
inti=0,count;
cout<<"请输入磁道序列(0结束):
"<A:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
A:
"<gotoA;//输入错误,跳转到A,重新输入}elsecidao[i]=trans(str,a);i++;while(cidao[i-1]!=0){cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0)cout<<"输入数据的类型错误,请重新输入!"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
gotoA;//输入错误,跳转到A,重新输入
cidao[i]=trans(str,a);
while(cidao[i-1]!
=0)
"<else{cidao[i]=trans(str,a);i++;}}count=i-1;//要访问的磁道数cout<<"你输入的磁道序列为:";for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
count=i-1;//要访问的磁道数
cout<<"你输入的磁道序列为:
for(i=0;i{cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
cout<}cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
cout<while(1){cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
while
cout<cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
cout<<"**********************************************"<cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
cout<<"******系统菜单******"<cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
cout<<"**********************************************"<cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
cout<<"******"<cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
cout<<"**1.先来先服务**"<cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
cout<<"******"<cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
cout<<"**********************************************"<cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
cout<<"**********************************************"<G:cout<<"请选择算法:";F:cin>>str;//对输入数据进行有效性判断a=decide(str);if(a==0){cout<<"输入数据的类型错误,请重新输入!"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
G:
cout<<"请选择算法:
F:
"<gotoF;//输入错误,跳转到F,重新输入}elsec=trans(str,a);if(c==5)break;if(c>5){cout<<"数据输入错误!请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
gotoF;//输入错误,跳转到F,重新输入
c=trans(str,a);
if(c==5)
if(c>5)
cout<<"数据输入错误!
请重新输入"<gotoG;}switch(c){case1://使用FCFS算法FCFS(cidao,count);break;case2://使用SSTF算法SSTF(cidao,count);break;case3://使用SCAN算法SCAN(cidao,count);break;case4://使用CSCAN算法CSCAN(cidao,count);break;}}} 2.1功能说明这一段程序的主要功能为:(1)这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。2.2接口说明本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 2.3局部数据结构本程序共有。。。个局部变量及数据结构,其类型定义及语义如下:主要代码:for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
gotoG;
switch(c)
case1:
//使用FCFS算法
FCFS(cidao,count);
case2:
//使用SSTF算法
SSTF(cidao,count);
case3:
//使用SCAN算法
SCAN(cidao,count);
case4:
//使用CSCAN算法
CSCAN(cidao,count);
2.1功能说明
这一段程序的主要功能为:
(1)这是一种比较简单的磁盘调度算法。
2.2接口说明
本程序的输入参数为:
磁盘请求序列:
2354862656567632
当前磁道号87
输出结果为:
2.3局部数据结构
本程序共有。
。
个局部变量及数据结构,其类型定义及语义如下:
for(i=0,j=1;j{sum+=abs(array[j]-array[i]);ave=(float)(sum)/(float)(m);} 2.4流程图 本程序的流程图如图2所示2.5以实例说明运行过程例如,本程序的输入参数为:磁盘请求序列:2354862656567632当前磁道号87输出结果为: 实际运行结果如下
2.4流程图
本程序的流程图如图2所示
2.5以实例说明运行过程
例如,
实际运行结果如下
copyright@ 2008-2022 冰豆网网站版权所有
经营许可证编号:鄂ICP备2022015515号-1