操作系统磁盘调度算法97120.docx
《操作系统磁盘调度算法97120.docx》由会员分享,可在线阅读,更多相关《操作系统磁盘调度算法97120.docx(15页珍藏版)》请在冰豆网上搜索。
操作系统磁盘调度算法97120
广州大学学生实验报告
开课学院及实验室:
计算机科学与工程实验室年月日
学院
计算机科学与教育软件学院
年级/专业/班
计科101
姓名
苏桂荣
学号
1006100059
实验课程名称
操作系统原理实验
成绩
实验项目名称
磁盘调度算法
指导老师
(***报告只能为文字和图片,老师评语将添加到此处,学生请勿作答***)
编程序实现下述磁盘调度算法,并求出每种算法的平均寻道长度:
1、先来先服务算法(FCFS)
2、最短寻道时间优先算法(SSTF)
3、扫描算法(SCAN)
#include
#include"stdlib.h"
usingnamespacestd;
voidFCFS(inta[],intn);
voidSSTF(inta[],intn);
voidSCAN(inta[],intn);
intmain()
{
intn;//磁道的个数
//ints;//选择键
intw;//磁道号生成方式
int*a=newint[n];//磁道号
//说明
cout<<"请输入磁道的个数:
";
cin>>n;
cout<cout<<"请选择磁道号的生成方式(1—随机生成,2—手动输入):";cin>>w;do{if(w!=1&&w!=2){cout<<"请选择1或2:";cin>>w;}if(w==1){/////////////////////////////////////////随机数产生srand((unsigned)time(NULL));for(inti=0;i{a[i]=rand()%100;}/////////////////////////////////////////随机数产生end}elseif(w==2){////////////////////////////////////手动输入磁道号for(inti=0;i{cin>>a[i];}////////////////////////////////////手动输入磁道号end}}while(w!=1&&w!=2);ints;while(1){cout</////////////////////////////////////////磁道号显示cout<<"生成的磁道号:";for(inti=0;i{cout<}/////////////////////////////////////////磁道号显示endcout<cout<<"|*************************************|"<cout<<"|请选择何种算法:|"<cout<<"|1、先来先服务算法(FCFS)|"<cout<<"|2、最短寻道时间算法(SSTF)|"<cout<<"|3、扫描算法(SCAN)|"<cout<<"|4、清除界面|"<cout<<"|0、退出|"<cout<<"|*************************************|"<cout<cout<<"请选择要用的功能:";cin>>s;if(s!=1&&s!=2&&s!=3&&s!=0&&s!=4){cout<<"输入有误!"<}else{switch(s){case0:{cout<<"|*************************************|"<cout<<"|感谢使用|"<cout<<"|如遇bug或有疑问联系|"<cout<<"|企鹅号:595296310|"<cout<<"|by-无风嘟嘟|"<cout<<"|*************************************|"<exit(0);break;}case1:FCFS(a,n);break;case2:SSTF(a,n);break;case3:SCAN(a,n);break;case4:system("cls");break;default:cout<<"请再次选择"<}}}return0;}///////////////////////////////////////////////////////////////////先来先服务FCFSvoidFCFS(inta[],intn){intsum=0,i,j,num1=0,now;floataverag;cout<cout<<"先来先服务算法(FCFS):"<cout<<"请输入当前磁道号:";cin>>now;cout<cout<<"磁盘调度顺序为:";for(i=0;i{cout<}//////////////////////////////////计算sumfor(i=0,j=1;j{num1+=abs(a[j]-a[i]);//外围磁道与最里面磁道的距离}sum+=num1+abs(now-a[0]);cout<cout<<"移动的总磁道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}//////////////////////////////////////////最短寻道时间算法SSTFvoidSSTF(inta[],intn){inttemp;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"最短寻道时间算法(SSTF):";////////////////////////将磁道号按递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}////////////////////将磁道号按递增排序end///////////////输出排好的磁道顺序cout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<///////////////输出排好的磁道顺序endcout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置////////////////////////////////////////////////////////以下算法确定磁道访问顺序cout<<"磁盘调度顺序为:";if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--){cout<}sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else{while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
cout<<"请选择磁道号的生成方式(1—随机生成,2—手动输入):
cin>>w;
do{
if(w!
=1&&w!
=2)
cout<<"请选择1或2:
}
if(w==1)
/////////////////////////////////////////随机数产生
srand((unsigned)time(NULL));
for(inti=0;i{a[i]=rand()%100;}/////////////////////////////////////////随机数产生end}elseif(w==2){////////////////////////////////////手动输入磁道号for(inti=0;i{cin>>a[i];}////////////////////////////////////手动输入磁道号end}}while(w!=1&&w!=2);ints;while(1){cout</////////////////////////////////////////磁道号显示cout<<"生成的磁道号:";for(inti=0;i{cout<}/////////////////////////////////////////磁道号显示endcout<cout<<"|*************************************|"<cout<<"|请选择何种算法:|"<cout<<"|1、先来先服务算法(FCFS)|"<cout<<"|2、最短寻道时间算法(SSTF)|"<cout<<"|3、扫描算法(SCAN)|"<cout<<"|4、清除界面|"<cout<<"|0、退出|"<cout<<"|*************************************|"<cout<cout<<"请选择要用的功能:";cin>>s;if(s!=1&&s!=2&&s!=3&&s!=0&&s!=4){cout<<"输入有误!"<}else{switch(s){case0:{cout<<"|*************************************|"<cout<<"|感谢使用|"<cout<<"|如遇bug或有疑问联系|"<cout<<"|企鹅号:595296310|"<cout<<"|by-无风嘟嘟|"<cout<<"|*************************************|"<exit(0);break;}case1:FCFS(a,n);break;case2:SSTF(a,n);break;case3:SCAN(a,n);break;case4:system("cls");break;default:cout<<"请再次选择"<}}}return0;}///////////////////////////////////////////////////////////////////先来先服务FCFSvoidFCFS(inta[],intn){intsum=0,i,j,num1=0,now;floataverag;cout<cout<<"先来先服务算法(FCFS):"<cout<<"请输入当前磁道号:";cin>>now;cout<cout<<"磁盘调度顺序为:";for(i=0;i{cout<}//////////////////////////////////计算sumfor(i=0,j=1;j{num1+=abs(a[j]-a[i]);//外围磁道与最里面磁道的距离}sum+=num1+abs(now-a[0]);cout<cout<<"移动的总磁道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}//////////////////////////////////////////最短寻道时间算法SSTFvoidSSTF(inta[],intn){inttemp;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"最短寻道时间算法(SSTF):";////////////////////////将磁道号按递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}////////////////////将磁道号按递增排序end///////////////输出排好的磁道顺序cout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<///////////////输出排好的磁道顺序endcout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置////////////////////////////////////////////////////////以下算法确定磁道访问顺序cout<<"磁盘调度顺序为:";if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--){cout<}sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else{while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
a[i]=rand()%100;
/////////////////////////////////////////随机数产生end
elseif(w==2)
////////////////////////////////////手动输入磁道号
for(inti=0;i{cin>>a[i];}////////////////////////////////////手动输入磁道号end}}while(w!=1&&w!=2);ints;while(1){cout</////////////////////////////////////////磁道号显示cout<<"生成的磁道号:";for(inti=0;i{cout<}/////////////////////////////////////////磁道号显示endcout<cout<<"|*************************************|"<cout<<"|请选择何种算法:|"<cout<<"|1、先来先服务算法(FCFS)|"<cout<<"|2、最短寻道时间算法(SSTF)|"<cout<<"|3、扫描算法(SCAN)|"<cout<<"|4、清除界面|"<cout<<"|0、退出|"<cout<<"|*************************************|"<cout<cout<<"请选择要用的功能:";cin>>s;if(s!=1&&s!=2&&s!=3&&s!=0&&s!=4){cout<<"输入有误!"<}else{switch(s){case0:{cout<<"|*************************************|"<cout<<"|感谢使用|"<cout<<"|如遇bug或有疑问联系|"<cout<<"|企鹅号:595296310|"<cout<<"|by-无风嘟嘟|"<cout<<"|*************************************|"<exit(0);break;}case1:FCFS(a,n);break;case2:SSTF(a,n);break;case3:SCAN(a,n);break;case4:system("cls");break;default:cout<<"请再次选择"<}}}return0;}///////////////////////////////////////////////////////////////////先来先服务FCFSvoidFCFS(inta[],intn){intsum=0,i,j,num1=0,now;floataverag;cout<cout<<"先来先服务算法(FCFS):"<cout<<"请输入当前磁道号:";cin>>now;cout<cout<<"磁盘调度顺序为:";for(i=0;i{cout<}//////////////////////////////////计算sumfor(i=0,j=1;j{num1+=abs(a[j]-a[i]);//外围磁道与最里面磁道的距离}sum+=num1+abs(now-a[0]);cout<cout<<"移动的总磁道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}//////////////////////////////////////////最短寻道时间算法SSTFvoidSSTF(inta[],intn){inttemp;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"最短寻道时间算法(SSTF):";////////////////////////将磁道号按递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}////////////////////将磁道号按递增排序end///////////////输出排好的磁道顺序cout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<///////////////输出排好的磁道顺序endcout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置////////////////////////////////////////////////////////以下算法确定磁道访问顺序cout<<"磁盘调度顺序为:";if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--){cout<}sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else{while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
cin>>a[i];
////////////////////////////////////手动输入磁道号end
}while(w!
=2);
ints;
while
(1)
cout</////////////////////////////////////////磁道号显示cout<<"生成的磁道号:";for(inti=0;i{cout<}/////////////////////////////////////////磁道号显示endcout<cout<<"|*************************************|"<cout<<"|请选择何种算法:|"<cout<<"|1、先来先服务算法(FCFS)|"<cout<<"|2、最短寻道时间算法(SSTF)|"<cout<<"|3、扫描算法(SCAN)|"<cout<<"|4、清除界面|"<cout<<"|0、退出|"<cout<<"|*************************************|"<cout<cout<<"请选择要用的功能:";cin>>s;if(s!=1&&s!=2&&s!=3&&s!=0&&s!=4){cout<<"输入有误!"<}else{switch(s){case0:{cout<<"|*************************************|"<cout<<"|感谢使用|"<cout<<"|如遇bug或有疑问联系|"<cout<<"|企鹅号:595296310|"<cout<<"|by-无风嘟嘟|"<cout<<"|*************************************|"<exit(0);break;}case1:FCFS(a,n);break;case2:SSTF(a,n);break;case3:SCAN(a,n);break;case4:system("cls");break;default:cout<<"请再次选择"<}}}return0;}///////////////////////////////////////////////////////////////////先来先服务FCFSvoidFCFS(inta[],intn){intsum=0,i,j,num1=0,now;floataverag;cout<cout<<"先来先服务算法(FCFS):"<cout<<"请输入当前磁道号:";cin>>now;cout<cout<<"磁盘调度顺序为:";for(i=0;i{cout<}//////////////////////////////////计算sumfor(i=0,j=1;j{num1+=abs(a[j]-a[i]);//外围磁道与最里面磁道的距离}sum+=num1+abs(now-a[0]);cout<cout<<"移动的总磁道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}//////////////////////////////////////////最短寻道时间算法SSTFvoidSSTF(inta[],intn){inttemp;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"最短寻道时间算法(SSTF):";////////////////////////将磁道号按递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}////////////////////将磁道号按递增排序end///////////////输出排好的磁道顺序cout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<///////////////输出排好的磁道顺序endcout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置////////////////////////////////////////////////////////以下算法确定磁道访问顺序cout<<"磁盘调度顺序为:";if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--){cout<}sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else{while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
/////////////////////////////////////////磁道号显示
cout<<"生成的磁道号:
for(inti=0;i{cout<}/////////////////////////////////////////磁道号显示endcout<cout<<"|*************************************|"<cout<<"|请选择何种算法:|"<cout<<"|1、先来先服务算法(FCFS)|"<cout<<"|2、最短寻道时间算法(SSTF)|"<cout<<"|3、扫描算法(SCAN)|"<cout<<"|4、清除界面|"<cout<<"|0、退出|"<cout<<"|*************************************|"<cout<cout<<"请选择要用的功能:";cin>>s;if(s!=1&&s!=2&&s!=3&&s!=0&&s!=4){cout<<"输入有误!"<}else{switch(s){case0:{cout<<"|*************************************|"<cout<<"|感谢使用|"<cout<<"|如遇bug或有疑问联系|"<cout<<"|企鹅号:595296310|"<cout<<"|by-无风嘟嘟|"<cout<<"|*************************************|"<exit(0);break;}case1:FCFS(a,n);break;case2:SSTF(a,n);break;case3:SCAN(a,n);break;case4:system("cls");break;default:cout<<"请再次选择"<}}}return0;}///////////////////////////////////////////////////////////////////先来先服务FCFSvoidFCFS(inta[],intn){intsum=0,i,j,num1=0,now;floataverag;cout<cout<<"先来先服务算法(FCFS):"<cout<<"请输入当前磁道号:";cin>>now;cout<cout<<"磁盘调度顺序为:";for(i=0;i{cout<}//////////////////////////////////计算sumfor(i=0,j=1;j{num1+=abs(a[j]-a[i]);//外围磁道与最里面磁道的距离}sum+=num1+abs(now-a[0]);cout<cout<<"移动的总磁道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}//////////////////////////////////////////最短寻道时间算法SSTFvoidSSTF(inta[],intn){inttemp;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"最短寻道时间算法(SSTF):";////////////////////////将磁道号按递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}////////////////////将磁道号按递增排序end///////////////输出排好的磁道顺序cout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<///////////////输出排好的磁道顺序endcout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置////////////////////////////////////////////////////////以下算法确定磁道访问顺序cout<<"磁盘调度顺序为:";if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--){cout<}sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else{while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
cout<}/////////////////////////////////////////磁道号显示endcout<cout<<"|*************************************|"<cout<<"|请选择何种算法:|"<cout<<"|1、先来先服务算法(FCFS)|"<cout<<"|2、最短寻道时间算法(SSTF)|"<cout<<"|3、扫描算法(SCAN)|"<cout<<"|4、清除界面|"<cout<<"|0、退出|"<cout<<"|*************************************|"<cout<cout<<"请选择要用的功能:";cin>>s;if(s!=1&&s!=2&&s!=3&&s!=0&&s!=4){cout<<"输入有误!"<}else{switch(s){case0:{cout<<"|*************************************|"<cout<<"|感谢使用|"<cout<<"|如遇bug或有疑问联系|"<cout<<"|企鹅号:595296310|"<cout<<"|by-无风嘟嘟|"<cout<<"|*************************************|"<exit(0);break;}case1:FCFS(a,n);break;case2:SSTF(a,n);break;case3:SCAN(a,n);break;case4:system("cls");break;default:cout<<"请再次选择"<}}}return0;}///////////////////////////////////////////////////////////////////先来先服务FCFSvoidFCFS(inta[],intn){intsum=0,i,j,num1=0,now;floataverag;cout<cout<<"先来先服务算法(FCFS):"<cout<<"请输入当前磁道号:";cin>>now;cout<cout<<"磁盘调度顺序为:";for(i=0;i{cout<}//////////////////////////////////计算sumfor(i=0,j=1;j{num1+=abs(a[j]-a[i]);//外围磁道与最里面磁道的距离}sum+=num1+abs(now-a[0]);cout<cout<<"移动的总磁道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}//////////////////////////////////////////最短寻道时间算法SSTFvoidSSTF(inta[],intn){inttemp;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"最短寻道时间算法(SSTF):";////////////////////////将磁道号按递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}////////////////////将磁道号按递增排序end///////////////输出排好的磁道顺序cout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<///////////////输出排好的磁道顺序endcout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置////////////////////////////////////////////////////////以下算法确定磁道访问顺序cout<<"磁盘调度顺序为:";if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--){cout<}sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else{while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
/////////////////////////////////////////磁道号显示end
cout<cout<<"|*************************************|"<cout<<"|请选择何种算法:|"<cout<<"|1、先来先服务算法(FCFS)|"<cout<<"|2、最短寻道时间算法(SSTF)|"<cout<<"|3、扫描算法(SCAN)|"<cout<<"|4、清除界面|"<cout<<"|0、退出|"<cout<<"|*************************************|"<cout<cout<<"请选择要用的功能:";cin>>s;if(s!=1&&s!=2&&s!=3&&s!=0&&s!=4){cout<<"输入有误!"<}else{switch(s){case0:{cout<<"|*************************************|"<cout<<"|感谢使用|"<cout<<"|如遇bug或有疑问联系|"<cout<<"|企鹅号:595296310|"<cout<<"|by-无风嘟嘟|"<cout<<"|*************************************|"<exit(0);break;}case1:FCFS(a,n);break;case2:SSTF(a,n);break;case3:SCAN(a,n);break;case4:system("cls");break;default:cout<<"请再次选择"<}}}return0;}///////////////////////////////////////////////////////////////////先来先服务FCFSvoidFCFS(inta[],intn){intsum=0,i,j,num1=0,now;floataverag;cout<cout<<"先来先服务算法(FCFS):"<cout<<"请输入当前磁道号:";cin>>now;cout<cout<<"磁盘调度顺序为:";for(i=0;i{cout<}//////////////////////////////////计算sumfor(i=0,j=1;j{num1+=abs(a[j]-a[i]);//外围磁道与最里面磁道的距离}sum+=num1+abs(now-a[0]);cout<cout<<"移动的总磁道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}//////////////////////////////////////////最短寻道时间算法SSTFvoidSSTF(inta[],intn){inttemp;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"最短寻道时间算法(SSTF):";////////////////////////将磁道号按递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}////////////////////将磁道号按递增排序end///////////////输出排好的磁道顺序cout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<///////////////输出排好的磁道顺序endcout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置////////////////////////////////////////////////////////以下算法确定磁道访问顺序cout<<"磁盘调度顺序为:";if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--){cout<}sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else{while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
cout<<"|*************************************|"<cout<<"|请选择何种算法:|"<cout<<"|1、先来先服务算法(FCFS)|"<cout<<"|2、最短寻道时间算法(SSTF)|"<cout<<"|3、扫描算法(SCAN)|"<cout<<"|4、清除界面|"<cout<<"|0、退出|"<cout<<"|*************************************|"<cout<cout<<"请选择要用的功能:";cin>>s;if(s!=1&&s!=2&&s!=3&&s!=0&&s!=4){cout<<"输入有误!"<}else{switch(s){case0:{cout<<"|*************************************|"<cout<<"|感谢使用|"<cout<<"|如遇bug或有疑问联系|"<cout<<"|企鹅号:595296310|"<cout<<"|by-无风嘟嘟|"<cout<<"|*************************************|"<exit(0);break;}case1:FCFS(a,n);break;case2:SSTF(a,n);break;case3:SCAN(a,n);break;case4:system("cls");break;default:cout<<"请再次选择"<}}}return0;}///////////////////////////////////////////////////////////////////先来先服务FCFSvoidFCFS(inta[],intn){intsum=0,i,j,num1=0,now;floataverag;cout<cout<<"先来先服务算法(FCFS):"<cout<<"请输入当前磁道号:";cin>>now;cout<cout<<"磁盘调度顺序为:";for(i=0;i{cout<}//////////////////////////////////计算sumfor(i=0,j=1;j{num1+=abs(a[j]-a[i]);//外围磁道与最里面磁道的距离}sum+=num1+abs(now-a[0]);cout<cout<<"移动的总磁道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}//////////////////////////////////////////最短寻道时间算法SSTFvoidSSTF(inta[],intn){inttemp;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"最短寻道时间算法(SSTF):";////////////////////////将磁道号按递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}////////////////////将磁道号按递增排序end///////////////输出排好的磁道顺序cout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<///////////////输出排好的磁道顺序endcout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置////////////////////////////////////////////////////////以下算法确定磁道访问顺序cout<<"磁盘调度顺序为:";if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--){cout<}sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else{while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
cout<<"|请选择何种算法:
|"<cout<<"|1、先来先服务算法(FCFS)|"<cout<<"|2、最短寻道时间算法(SSTF)|"<cout<<"|3、扫描算法(SCAN)|"<cout<<"|4、清除界面|"<cout<<"|0、退出|"<cout<<"|*************************************|"<cout<cout<<"请选择要用的功能:";cin>>s;if(s!=1&&s!=2&&s!=3&&s!=0&&s!=4){cout<<"输入有误!"<}else{switch(s){case0:{cout<<"|*************************************|"<cout<<"|感谢使用|"<cout<<"|如遇bug或有疑问联系|"<cout<<"|企鹅号:595296310|"<cout<<"|by-无风嘟嘟|"<cout<<"|*************************************|"<exit(0);break;}case1:FCFS(a,n);break;case2:SSTF(a,n);break;case3:SCAN(a,n);break;case4:system("cls");break;default:cout<<"请再次选择"<}}}return0;}///////////////////////////////////////////////////////////////////先来先服务FCFSvoidFCFS(inta[],intn){intsum=0,i,j,num1=0,now;floataverag;cout<cout<<"先来先服务算法(FCFS):"<cout<<"请输入当前磁道号:";cin>>now;cout<cout<<"磁盘调度顺序为:";for(i=0;i{cout<}//////////////////////////////////计算sumfor(i=0,j=1;j{num1+=abs(a[j]-a[i]);//外围磁道与最里面磁道的距离}sum+=num1+abs(now-a[0]);cout<cout<<"移动的总磁道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}//////////////////////////////////////////最短寻道时间算法SSTFvoidSSTF(inta[],intn){inttemp;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"最短寻道时间算法(SSTF):";////////////////////////将磁道号按递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}////////////////////将磁道号按递增排序end///////////////输出排好的磁道顺序cout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<///////////////输出排好的磁道顺序endcout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置////////////////////////////////////////////////////////以下算法确定磁道访问顺序cout<<"磁盘调度顺序为:";if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--){cout<}sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else{while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
cout<<"|1、先来先服务算法(FCFS)|"<cout<<"|2、最短寻道时间算法(SSTF)|"<cout<<"|3、扫描算法(SCAN)|"<cout<<"|4、清除界面|"<cout<<"|0、退出|"<cout<<"|*************************************|"<cout<cout<<"请选择要用的功能:";cin>>s;if(s!=1&&s!=2&&s!=3&&s!=0&&s!=4){cout<<"输入有误!"<}else{switch(s){case0:{cout<<"|*************************************|"<cout<<"|感谢使用|"<cout<<"|如遇bug或有疑问联系|"<cout<<"|企鹅号:595296310|"<cout<<"|by-无风嘟嘟|"<cout<<"|*************************************|"<exit(0);break;}case1:FCFS(a,n);break;case2:SSTF(a,n);break;case3:SCAN(a,n);break;case4:system("cls");break;default:cout<<"请再次选择"<}}}return0;}///////////////////////////////////////////////////////////////////先来先服务FCFSvoidFCFS(inta[],intn){intsum=0,i,j,num1=0,now;floataverag;cout<cout<<"先来先服务算法(FCFS):"<cout<<"请输入当前磁道号:";cin>>now;cout<cout<<"磁盘调度顺序为:";for(i=0;i{cout<}//////////////////////////////////计算sumfor(i=0,j=1;j{num1+=abs(a[j]-a[i]);//外围磁道与最里面磁道的距离}sum+=num1+abs(now-a[0]);cout<cout<<"移动的总磁道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}//////////////////////////////////////////最短寻道时间算法SSTFvoidSSTF(inta[],intn){inttemp;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"最短寻道时间算法(SSTF):";////////////////////////将磁道号按递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}////////////////////将磁道号按递增排序end///////////////输出排好的磁道顺序cout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<///////////////输出排好的磁道顺序endcout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置////////////////////////////////////////////////////////以下算法确定磁道访问顺序cout<<"磁盘调度顺序为:";if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--){cout<}sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else{while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
cout<<"|2、最短寻道时间算法(SSTF)|"<cout<<"|3、扫描算法(SCAN)|"<cout<<"|4、清除界面|"<cout<<"|0、退出|"<cout<<"|*************************************|"<cout<cout<<"请选择要用的功能:";cin>>s;if(s!=1&&s!=2&&s!=3&&s!=0&&s!=4){cout<<"输入有误!"<}else{switch(s){case0:{cout<<"|*************************************|"<cout<<"|感谢使用|"<cout<<"|如遇bug或有疑问联系|"<cout<<"|企鹅号:595296310|"<cout<<"|by-无风嘟嘟|"<cout<<"|*************************************|"<exit(0);break;}case1:FCFS(a,n);break;case2:SSTF(a,n);break;case3:SCAN(a,n);break;case4:system("cls");break;default:cout<<"请再次选择"<}}}return0;}///////////////////////////////////////////////////////////////////先来先服务FCFSvoidFCFS(inta[],intn){intsum=0,i,j,num1=0,now;floataverag;cout<cout<<"先来先服务算法(FCFS):"<cout<<"请输入当前磁道号:";cin>>now;cout<cout<<"磁盘调度顺序为:";for(i=0;i{cout<}//////////////////////////////////计算sumfor(i=0,j=1;j{num1+=abs(a[j]-a[i]);//外围磁道与最里面磁道的距离}sum+=num1+abs(now-a[0]);cout<cout<<"移动的总磁道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}//////////////////////////////////////////最短寻道时间算法SSTFvoidSSTF(inta[],intn){inttemp;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"最短寻道时间算法(SSTF):";////////////////////////将磁道号按递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}////////////////////将磁道号按递增排序end///////////////输出排好的磁道顺序cout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<///////////////输出排好的磁道顺序endcout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置////////////////////////////////////////////////////////以下算法确定磁道访问顺序cout<<"磁盘调度顺序为:";if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--){cout<}sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else{while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
cout<<"|3、扫描算法(SCAN)|"<cout<<"|4、清除界面|"<cout<<"|0、退出|"<cout<<"|*************************************|"<cout<cout<<"请选择要用的功能:";cin>>s;if(s!=1&&s!=2&&s!=3&&s!=0&&s!=4){cout<<"输入有误!"<}else{switch(s){case0:{cout<<"|*************************************|"<cout<<"|感谢使用|"<cout<<"|如遇bug或有疑问联系|"<cout<<"|企鹅号:595296310|"<cout<<"|by-无风嘟嘟|"<cout<<"|*************************************|"<exit(0);break;}case1:FCFS(a,n);break;case2:SSTF(a,n);break;case3:SCAN(a,n);break;case4:system("cls");break;default:cout<<"请再次选择"<}}}return0;}///////////////////////////////////////////////////////////////////先来先服务FCFSvoidFCFS(inta[],intn){intsum=0,i,j,num1=0,now;floataverag;cout<cout<<"先来先服务算法(FCFS):"<cout<<"请输入当前磁道号:";cin>>now;cout<cout<<"磁盘调度顺序为:";for(i=0;i{cout<}//////////////////////////////////计算sumfor(i=0,j=1;j{num1+=abs(a[j]-a[i]);//外围磁道与最里面磁道的距离}sum+=num1+abs(now-a[0]);cout<cout<<"移动的总磁道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}//////////////////////////////////////////最短寻道时间算法SSTFvoidSSTF(inta[],intn){inttemp;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"最短寻道时间算法(SSTF):";////////////////////////将磁道号按递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}////////////////////将磁道号按递增排序end///////////////输出排好的磁道顺序cout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<///////////////输出排好的磁道顺序endcout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置////////////////////////////////////////////////////////以下算法确定磁道访问顺序cout<<"磁盘调度顺序为:";if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--){cout<}sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else{while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
cout<<"|4、清除界面|"<cout<<"|0、退出|"<cout<<"|*************************************|"<cout<cout<<"请选择要用的功能:";cin>>s;if(s!=1&&s!=2&&s!=3&&s!=0&&s!=4){cout<<"输入有误!"<}else{switch(s){case0:{cout<<"|*************************************|"<cout<<"|感谢使用|"<cout<<"|如遇bug或有疑问联系|"<cout<<"|企鹅号:595296310|"<cout<<"|by-无风嘟嘟|"<cout<<"|*************************************|"<exit(0);break;}case1:FCFS(a,n);break;case2:SSTF(a,n);break;case3:SCAN(a,n);break;case4:system("cls");break;default:cout<<"请再次选择"<}}}return0;}///////////////////////////////////////////////////////////////////先来先服务FCFSvoidFCFS(inta[],intn){intsum=0,i,j,num1=0,now;floataverag;cout<cout<<"先来先服务算法(FCFS):"<cout<<"请输入当前磁道号:";cin>>now;cout<cout<<"磁盘调度顺序为:";for(i=0;i{cout<}//////////////////////////////////计算sumfor(i=0,j=1;j{num1+=abs(a[j]-a[i]);//外围磁道与最里面磁道的距离}sum+=num1+abs(now-a[0]);cout<cout<<"移动的总磁道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}//////////////////////////////////////////最短寻道时间算法SSTFvoidSSTF(inta[],intn){inttemp;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"最短寻道时间算法(SSTF):";////////////////////////将磁道号按递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}////////////////////将磁道号按递增排序end///////////////输出排好的磁道顺序cout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<///////////////输出排好的磁道顺序endcout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置////////////////////////////////////////////////////////以下算法确定磁道访问顺序cout<<"磁盘调度顺序为:";if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--){cout<}sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else{while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
cout<<"|0、退出|"<cout<<"|*************************************|"<cout<cout<<"请选择要用的功能:";cin>>s;if(s!=1&&s!=2&&s!=3&&s!=0&&s!=4){cout<<"输入有误!"<}else{switch(s){case0:{cout<<"|*************************************|"<cout<<"|感谢使用|"<cout<<"|如遇bug或有疑问联系|"<cout<<"|企鹅号:595296310|"<cout<<"|by-无风嘟嘟|"<cout<<"|*************************************|"<exit(0);break;}case1:FCFS(a,n);break;case2:SSTF(a,n);break;case3:SCAN(a,n);break;case4:system("cls");break;default:cout<<"请再次选择"<}}}return0;}///////////////////////////////////////////////////////////////////先来先服务FCFSvoidFCFS(inta[],intn){intsum=0,i,j,num1=0,now;floataverag;cout<cout<<"先来先服务算法(FCFS):"<cout<<"请输入当前磁道号:";cin>>now;cout<cout<<"磁盘调度顺序为:";for(i=0;i{cout<}//////////////////////////////////计算sumfor(i=0,j=1;j{num1+=abs(a[j]-a[i]);//外围磁道与最里面磁道的距离}sum+=num1+abs(now-a[0]);cout<cout<<"移动的总磁道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}//////////////////////////////////////////最短寻道时间算法SSTFvoidSSTF(inta[],intn){inttemp;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"最短寻道时间算法(SSTF):";////////////////////////将磁道号按递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}////////////////////将磁道号按递增排序end///////////////输出排好的磁道顺序cout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<///////////////输出排好的磁道顺序endcout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置////////////////////////////////////////////////////////以下算法确定磁道访问顺序cout<<"磁盘调度顺序为:";if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--){cout<}sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else{while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
cout<<"|*************************************|"<cout<cout<<"请选择要用的功能:";cin>>s;if(s!=1&&s!=2&&s!=3&&s!=0&&s!=4){cout<<"输入有误!"<}else{switch(s){case0:{cout<<"|*************************************|"<cout<<"|感谢使用|"<cout<<"|如遇bug或有疑问联系|"<cout<<"|企鹅号:595296310|"<cout<<"|by-无风嘟嘟|"<cout<<"|*************************************|"<exit(0);break;}case1:FCFS(a,n);break;case2:SSTF(a,n);break;case3:SCAN(a,n);break;case4:system("cls");break;default:cout<<"请再次选择"<}}}return0;}///////////////////////////////////////////////////////////////////先来先服务FCFSvoidFCFS(inta[],intn){intsum=0,i,j,num1=0,now;floataverag;cout<cout<<"先来先服务算法(FCFS):"<cout<<"请输入当前磁道号:";cin>>now;cout<cout<<"磁盘调度顺序为:";for(i=0;i{cout<}//////////////////////////////////计算sumfor(i=0,j=1;j{num1+=abs(a[j]-a[i]);//外围磁道与最里面磁道的距离}sum+=num1+abs(now-a[0]);cout<cout<<"移动的总磁道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}//////////////////////////////////////////最短寻道时间算法SSTFvoidSSTF(inta[],intn){inttemp;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"最短寻道时间算法(SSTF):";////////////////////////将磁道号按递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}////////////////////将磁道号按递增排序end///////////////输出排好的磁道顺序cout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<///////////////输出排好的磁道顺序endcout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置////////////////////////////////////////////////////////以下算法确定磁道访问顺序cout<<"磁盘调度顺序为:";if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--){cout<}sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else{while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
cout<cout<<"请选择要用的功能:";cin>>s;if(s!=1&&s!=2&&s!=3&&s!=0&&s!=4){cout<<"输入有误!"<}else{switch(s){case0:{cout<<"|*************************************|"<cout<<"|感谢使用|"<cout<<"|如遇bug或有疑问联系|"<cout<<"|企鹅号:595296310|"<cout<<"|by-无风嘟嘟|"<cout<<"|*************************************|"<exit(0);break;}case1:FCFS(a,n);break;case2:SSTF(a,n);break;case3:SCAN(a,n);break;case4:system("cls");break;default:cout<<"请再次选择"<}}}return0;}///////////////////////////////////////////////////////////////////先来先服务FCFSvoidFCFS(inta[],intn){intsum=0,i,j,num1=0,now;floataverag;cout<cout<<"先来先服务算法(FCFS):"<cout<<"请输入当前磁道号:";cin>>now;cout<cout<<"磁盘调度顺序为:";for(i=0;i{cout<}//////////////////////////////////计算sumfor(i=0,j=1;j{num1+=abs(a[j]-a[i]);//外围磁道与最里面磁道的距离}sum+=num1+abs(now-a[0]);cout<cout<<"移动的总磁道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}//////////////////////////////////////////最短寻道时间算法SSTFvoidSSTF(inta[],intn){inttemp;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"最短寻道时间算法(SSTF):";////////////////////////将磁道号按递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}////////////////////将磁道号按递增排序end///////////////输出排好的磁道顺序cout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<///////////////输出排好的磁道顺序endcout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置////////////////////////////////////////////////////////以下算法确定磁道访问顺序cout<<"磁盘调度顺序为:";if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--){cout<}sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else{while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
cout<<"请选择要用的功能:
cin>>s;
if(s!
=1&&s!
=2&&s!
=3&&s!
=0&&s!
=4)
cout<<"输入有误!
"<}else{switch(s){case0:{cout<<"|*************************************|"<cout<<"|感谢使用|"<cout<<"|如遇bug或有疑问联系|"<cout<<"|企鹅号:595296310|"<cout<<"|by-无风嘟嘟|"<cout<<"|*************************************|"<exit(0);break;}case1:FCFS(a,n);break;case2:SSTF(a,n);break;case3:SCAN(a,n);break;case4:system("cls");break;default:cout<<"请再次选择"<}}}return0;}///////////////////////////////////////////////////////////////////先来先服务FCFSvoidFCFS(inta[],intn){intsum=0,i,j,num1=0,now;floataverag;cout<cout<<"先来先服务算法(FCFS):"<cout<<"请输入当前磁道号:";cin>>now;cout<cout<<"磁盘调度顺序为:";for(i=0;i{cout<}//////////////////////////////////计算sumfor(i=0,j=1;j{num1+=abs(a[j]-a[i]);//外围磁道与最里面磁道的距离}sum+=num1+abs(now-a[0]);cout<cout<<"移动的总磁道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}//////////////////////////////////////////最短寻道时间算法SSTFvoidSSTF(inta[],intn){inttemp;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"最短寻道时间算法(SSTF):";////////////////////////将磁道号按递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}////////////////////将磁道号按递增排序end///////////////输出排好的磁道顺序cout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<///////////////输出排好的磁道顺序endcout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置////////////////////////////////////////////////////////以下算法确定磁道访问顺序cout<<"磁盘调度顺序为:";if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--){cout<}sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else{while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
else
switch(s)
case0:
cout<<"|*************************************|"<cout<<"|感谢使用|"<cout<<"|如遇bug或有疑问联系|"<cout<<"|企鹅号:595296310|"<cout<<"|by-无风嘟嘟|"<cout<<"|*************************************|"<exit(0);break;}case1:FCFS(a,n);break;case2:SSTF(a,n);break;case3:SCAN(a,n);break;case4:system("cls");break;default:cout<<"请再次选择"<}}}return0;}///////////////////////////////////////////////////////////////////先来先服务FCFSvoidFCFS(inta[],intn){intsum=0,i,j,num1=0,now;floataverag;cout<cout<<"先来先服务算法(FCFS):"<cout<<"请输入当前磁道号:";cin>>now;cout<cout<<"磁盘调度顺序为:";for(i=0;i{cout<}//////////////////////////////////计算sumfor(i=0,j=1;j{num1+=abs(a[j]-a[i]);//外围磁道与最里面磁道的距离}sum+=num1+abs(now-a[0]);cout<cout<<"移动的总磁道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}//////////////////////////////////////////最短寻道时间算法SSTFvoidSSTF(inta[],intn){inttemp;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"最短寻道时间算法(SSTF):";////////////////////////将磁道号按递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}////////////////////将磁道号按递增排序end///////////////输出排好的磁道顺序cout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<///////////////输出排好的磁道顺序endcout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置////////////////////////////////////////////////////////以下算法确定磁道访问顺序cout<<"磁盘调度顺序为:";if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--){cout<}sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else{while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
cout<<"|感谢使用|"<cout<<"|如遇bug或有疑问联系|"<cout<<"|企鹅号:595296310|"<cout<<"|by-无风嘟嘟|"<cout<<"|*************************************|"<exit(0);break;}case1:FCFS(a,n);break;case2:SSTF(a,n);break;case3:SCAN(a,n);break;case4:system("cls");break;default:cout<<"请再次选择"<}}}return0;}///////////////////////////////////////////////////////////////////先来先服务FCFSvoidFCFS(inta[],intn){intsum=0,i,j,num1=0,now;floataverag;cout<cout<<"先来先服务算法(FCFS):"<cout<<"请输入当前磁道号:";cin>>now;cout<cout<<"磁盘调度顺序为:";for(i=0;i{cout<}//////////////////////////////////计算sumfor(i=0,j=1;j{num1+=abs(a[j]-a[i]);//外围磁道与最里面磁道的距离}sum+=num1+abs(now-a[0]);cout<cout<<"移动的总磁道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}//////////////////////////////////////////最短寻道时间算法SSTFvoidSSTF(inta[],intn){inttemp;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"最短寻道时间算法(SSTF):";////////////////////////将磁道号按递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}////////////////////将磁道号按递增排序end///////////////输出排好的磁道顺序cout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<///////////////输出排好的磁道顺序endcout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置////////////////////////////////////////////////////////以下算法确定磁道访问顺序cout<<"磁盘调度顺序为:";if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--){cout<}sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else{while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
cout<<"|如遇bug或有疑问联系|"<cout<<"|企鹅号:595296310|"<cout<<"|by-无风嘟嘟|"<cout<<"|*************************************|"<exit(0);break;}case1:FCFS(a,n);break;case2:SSTF(a,n);break;case3:SCAN(a,n);break;case4:system("cls");break;default:cout<<"请再次选择"<}}}return0;}///////////////////////////////////////////////////////////////////先来先服务FCFSvoidFCFS(inta[],intn){intsum=0,i,j,num1=0,now;floataverag;cout<cout<<"先来先服务算法(FCFS):"<cout<<"请输入当前磁道号:";cin>>now;cout<cout<<"磁盘调度顺序为:";for(i=0;i{cout<}//////////////////////////////////计算sumfor(i=0,j=1;j{num1+=abs(a[j]-a[i]);//外围磁道与最里面磁道的距离}sum+=num1+abs(now-a[0]);cout<cout<<"移动的总磁道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}//////////////////////////////////////////最短寻道时间算法SSTFvoidSSTF(inta[],intn){inttemp;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"最短寻道时间算法(SSTF):";////////////////////////将磁道号按递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}////////////////////将磁道号按递增排序end///////////////输出排好的磁道顺序cout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<///////////////输出排好的磁道顺序endcout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置////////////////////////////////////////////////////////以下算法确定磁道访问顺序cout<<"磁盘调度顺序为:";if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--){cout<}sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else{while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
cout<<"|企鹅号:
595296310|"<cout<<"|by-无风嘟嘟|"<cout<<"|*************************************|"<exit(0);break;}case1:FCFS(a,n);break;case2:SSTF(a,n);break;case3:SCAN(a,n);break;case4:system("cls");break;default:cout<<"请再次选择"<}}}return0;}///////////////////////////////////////////////////////////////////先来先服务FCFSvoidFCFS(inta[],intn){intsum=0,i,j,num1=0,now;floataverag;cout<cout<<"先来先服务算法(FCFS):"<cout<<"请输入当前磁道号:";cin>>now;cout<cout<<"磁盘调度顺序为:";for(i=0;i{cout<}//////////////////////////////////计算sumfor(i=0,j=1;j{num1+=abs(a[j]-a[i]);//外围磁道与最里面磁道的距离}sum+=num1+abs(now-a[0]);cout<cout<<"移动的总磁道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}//////////////////////////////////////////最短寻道时间算法SSTFvoidSSTF(inta[],intn){inttemp;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"最短寻道时间算法(SSTF):";////////////////////////将磁道号按递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}////////////////////将磁道号按递增排序end///////////////输出排好的磁道顺序cout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<///////////////输出排好的磁道顺序endcout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置////////////////////////////////////////////////////////以下算法确定磁道访问顺序cout<<"磁盘调度顺序为:";if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--){cout<}sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else{while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
cout<<"|by-无风嘟嘟|"<cout<<"|*************************************|"<exit(0);break;}case1:FCFS(a,n);break;case2:SSTF(a,n);break;case3:SCAN(a,n);break;case4:system("cls");break;default:cout<<"请再次选择"<}}}return0;}///////////////////////////////////////////////////////////////////先来先服务FCFSvoidFCFS(inta[],intn){intsum=0,i,j,num1=0,now;floataverag;cout<cout<<"先来先服务算法(FCFS):"<cout<<"请输入当前磁道号:";cin>>now;cout<cout<<"磁盘调度顺序为:";for(i=0;i{cout<}//////////////////////////////////计算sumfor(i=0,j=1;j{num1+=abs(a[j]-a[i]);//外围磁道与最里面磁道的距离}sum+=num1+abs(now-a[0]);cout<cout<<"移动的总磁道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}//////////////////////////////////////////最短寻道时间算法SSTFvoidSSTF(inta[],intn){inttemp;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"最短寻道时间算法(SSTF):";////////////////////////将磁道号按递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}////////////////////将磁道号按递增排序end///////////////输出排好的磁道顺序cout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<///////////////输出排好的磁道顺序endcout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置////////////////////////////////////////////////////////以下算法确定磁道访问顺序cout<<"磁盘调度顺序为:";if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--){cout<}sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else{while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
cout<<"|*************************************|"<exit(0);break;}case1:FCFS(a,n);break;case2:SSTF(a,n);break;case3:SCAN(a,n);break;case4:system("cls");break;default:cout<<"请再次选择"<}}}return0;}///////////////////////////////////////////////////////////////////先来先服务FCFSvoidFCFS(inta[],intn){intsum=0,i,j,num1=0,now;floataverag;cout<cout<<"先来先服务算法(FCFS):"<cout<<"请输入当前磁道号:";cin>>now;cout<cout<<"磁盘调度顺序为:";for(i=0;i{cout<}//////////////////////////////////计算sumfor(i=0,j=1;j{num1+=abs(a[j]-a[i]);//外围磁道与最里面磁道的距离}sum+=num1+abs(now-a[0]);cout<cout<<"移动的总磁道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}//////////////////////////////////////////最短寻道时间算法SSTFvoidSSTF(inta[],intn){inttemp;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"最短寻道时间算法(SSTF):";////////////////////////将磁道号按递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}////////////////////将磁道号按递增排序end///////////////输出排好的磁道顺序cout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<///////////////输出排好的磁道顺序endcout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置////////////////////////////////////////////////////////以下算法确定磁道访问顺序cout<<"磁盘调度顺序为:";if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--){cout<}sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else{while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
exit(0);
break;
case1:
FCFS(a,n);break;
case2:
SSTF(a,n);break;
case3:
SCAN(a,n);break;
case4:
system("cls");break;
default:
cout<<"请再次选择"<}}}return0;}///////////////////////////////////////////////////////////////////先来先服务FCFSvoidFCFS(inta[],intn){intsum=0,i,j,num1=0,now;floataverag;cout<cout<<"先来先服务算法(FCFS):"<cout<<"请输入当前磁道号:";cin>>now;cout<cout<<"磁盘调度顺序为:";for(i=0;i{cout<}//////////////////////////////////计算sumfor(i=0,j=1;j{num1+=abs(a[j]-a[i]);//外围磁道与最里面磁道的距离}sum+=num1+abs(now-a[0]);cout<cout<<"移动的总磁道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}//////////////////////////////////////////最短寻道时间算法SSTFvoidSSTF(inta[],intn){inttemp;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"最短寻道时间算法(SSTF):";////////////////////////将磁道号按递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}////////////////////将磁道号按递增排序end///////////////输出排好的磁道顺序cout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<///////////////输出排好的磁道顺序endcout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置////////////////////////////////////////////////////////以下算法确定磁道访问顺序cout<<"磁盘调度顺序为:";if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--){cout<}sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else{while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
return0;
///////////////////////////////////////////////////////////////////先来先服务FCFS
voidFCFS(inta[],intn)
intsum=0,i,j,num1=0,now;
floataverag;
cout<cout<<"先来先服务算法(FCFS):"<cout<<"请输入当前磁道号:";cin>>now;cout<cout<<"磁盘调度顺序为:";for(i=0;i{cout<}//////////////////////////////////计算sumfor(i=0,j=1;j{num1+=abs(a[j]-a[i]);//外围磁道与最里面磁道的距离}sum+=num1+abs(now-a[0]);cout<cout<<"移动的总磁道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}//////////////////////////////////////////最短寻道时间算法SSTFvoidSSTF(inta[],intn){inttemp;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"最短寻道时间算法(SSTF):";////////////////////////将磁道号按递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}////////////////////将磁道号按递增排序end///////////////输出排好的磁道顺序cout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<///////////////输出排好的磁道顺序endcout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置////////////////////////////////////////////////////////以下算法确定磁道访问顺序cout<<"磁盘调度顺序为:";if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--){cout<}sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else{while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
cout<<"先来先服务算法(FCFS):
"<cout<<"请输入当前磁道号:";cin>>now;cout<cout<<"磁盘调度顺序为:";for(i=0;i{cout<}//////////////////////////////////计算sumfor(i=0,j=1;j{num1+=abs(a[j]-a[i]);//外围磁道与最里面磁道的距离}sum+=num1+abs(now-a[0]);cout<cout<<"移动的总磁道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}//////////////////////////////////////////最短寻道时间算法SSTFvoidSSTF(inta[],intn){inttemp;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"最短寻道时间算法(SSTF):";////////////////////////将磁道号按递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}////////////////////将磁道号按递增排序end///////////////输出排好的磁道顺序cout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<///////////////输出排好的磁道顺序endcout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置////////////////////////////////////////////////////////以下算法确定磁道访问顺序cout<<"磁盘调度顺序为:";if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--){cout<}sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else{while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
cout<<"请输入当前磁道号:
cin>>now;
cout<cout<<"磁盘调度顺序为:";for(i=0;i{cout<}//////////////////////////////////计算sumfor(i=0,j=1;j{num1+=abs(a[j]-a[i]);//外围磁道与最里面磁道的距离}sum+=num1+abs(now-a[0]);cout<cout<<"移动的总磁道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}//////////////////////////////////////////最短寻道时间算法SSTFvoidSSTF(inta[],intn){inttemp;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"最短寻道时间算法(SSTF):";////////////////////////将磁道号按递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}////////////////////将磁道号按递增排序end///////////////输出排好的磁道顺序cout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<///////////////输出排好的磁道顺序endcout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置////////////////////////////////////////////////////////以下算法确定磁道访问顺序cout<<"磁盘调度顺序为:";if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--){cout<}sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else{while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
cout<<"磁盘调度顺序为:
for(i=0;i{cout<}//////////////////////////////////计算sumfor(i=0,j=1;j{num1+=abs(a[j]-a[i]);//外围磁道与最里面磁道的距离}sum+=num1+abs(now-a[0]);cout<cout<<"移动的总磁道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}//////////////////////////////////////////最短寻道时间算法SSTFvoidSSTF(inta[],intn){inttemp;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"最短寻道时间算法(SSTF):";////////////////////////将磁道号按递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}////////////////////将磁道号按递增排序end///////////////输出排好的磁道顺序cout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<///////////////输出排好的磁道顺序endcout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置////////////////////////////////////////////////////////以下算法确定磁道访问顺序cout<<"磁盘调度顺序为:";if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--){cout<}sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else{while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
cout<}//////////////////////////////////计算sumfor(i=0,j=1;j{num1+=abs(a[j]-a[i]);//外围磁道与最里面磁道的距离}sum+=num1+abs(now-a[0]);cout<cout<<"移动的总磁道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}//////////////////////////////////////////最短寻道时间算法SSTFvoidSSTF(inta[],intn){inttemp;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"最短寻道时间算法(SSTF):";////////////////////////将磁道号按递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}////////////////////将磁道号按递增排序end///////////////输出排好的磁道顺序cout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<///////////////输出排好的磁道顺序endcout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置////////////////////////////////////////////////////////以下算法确定磁道访问顺序cout<<"磁盘调度顺序为:";if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--){cout<}sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else{while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
//////////////////////////////////计算sum
for(i=0,j=1;j{num1+=abs(a[j]-a[i]);//外围磁道与最里面磁道的距离}sum+=num1+abs(now-a[0]);cout<cout<<"移动的总磁道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}//////////////////////////////////////////最短寻道时间算法SSTFvoidSSTF(inta[],intn){inttemp;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"最短寻道时间算法(SSTF):";////////////////////////将磁道号按递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}////////////////////将磁道号按递增排序end///////////////输出排好的磁道顺序cout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<///////////////输出排好的磁道顺序endcout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置////////////////////////////////////////////////////////以下算法确定磁道访问顺序cout<<"磁盘调度顺序为:";if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--){cout<}sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else{while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
num1+=abs(a[j]-a[i]);//外围磁道与最里面磁道的距离
sum+=num1+abs(now-a[0]);
cout<cout<<"移动的总磁道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}//////////////////////////////////////////最短寻道时间算法SSTFvoidSSTF(inta[],intn){inttemp;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"最短寻道时间算法(SSTF):";////////////////////////将磁道号按递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}////////////////////将磁道号按递增排序end///////////////输出排好的磁道顺序cout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<///////////////输出排好的磁道顺序endcout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置////////////////////////////////////////////////////////以下算法确定磁道访问顺序cout<<"磁盘调度顺序为:";if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--){cout<}sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else{while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
cout<<"移动的总磁道数:
"<averag=float(sum)/n;cout<<"平均寻道长度:"<}//////////////////////////////////////////最短寻道时间算法SSTFvoidSSTF(inta[],intn){inttemp;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"最短寻道时间算法(SSTF):";////////////////////////将磁道号按递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}////////////////////将磁道号按递增排序end///////////////输出排好的磁道顺序cout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<///////////////输出排好的磁道顺序endcout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置////////////////////////////////////////////////////////以下算法确定磁道访问顺序cout<<"磁盘调度顺序为:";if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--){cout<}sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else{while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
averag=float(sum)/n;
cout<<"平均寻道长度:
"<}//////////////////////////////////////////最短寻道时间算法SSTFvoidSSTF(inta[],intn){inttemp;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"最短寻道时间算法(SSTF):";////////////////////////将磁道号按递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}////////////////////将磁道号按递增排序end///////////////输出排好的磁道顺序cout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<///////////////输出排好的磁道顺序endcout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置////////////////////////////////////////////////////////以下算法确定磁道访问顺序cout<<"磁盘调度顺序为:";if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--){cout<}sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else{while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
//////////////////////////////////////////最短寻道时间算法SSTF
voidSSTF(inta[],intn)
inttemp;
intk=1;
intnow,l,r;
inti,j,sum=0;
cout<cout<<"最短寻道时间算法(SSTF):";////////////////////////将磁道号按递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}////////////////////将磁道号按递增排序end///////////////输出排好的磁道顺序cout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<///////////////输出排好的磁道顺序endcout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置////////////////////////////////////////////////////////以下算法确定磁道访问顺序cout<<"磁盘调度顺序为:";if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--){cout<}sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else{while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
cout<<"最短寻道时间算法(SSTF):
////////////////////////将磁道号按递增排序
for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}////////////////////将磁道号按递增排序end///////////////输出排好的磁道顺序cout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<///////////////输出排好的磁道顺序endcout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置////////////////////////////////////////////////////////以下算法确定磁道访问顺序cout<<"磁盘调度顺序为:";if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--){cout<}sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else{while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}////////////////////将磁道号按递增排序end///////////////输出排好的磁道顺序cout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<///////////////输出排好的磁道顺序endcout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置////////////////////////////////////////////////////////以下算法确定磁道访问顺序cout<<"磁盘调度顺序为:";if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--){cout<}sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else{while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
if(a[i]>a[j])
temp=a[i];
a[i]=a[j];
a[j]=temp;
////////////////////将磁道号按递增排序end
///////////////输出排好的磁道顺序
cout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<///////////////输出排好的磁道顺序endcout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置////////////////////////////////////////////////////////以下算法确定磁道访问顺序cout<<"磁盘调度顺序为:";if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--){cout<}sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else{while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
cout<<"按递增顺序排好的磁道:
for(i=0;i{cout<}cout<cout<///////////////输出排好的磁道顺序endcout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置////////////////////////////////////////////////////////以下算法确定磁道访问顺序cout<<"磁盘调度顺序为:";if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--){cout<}sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else{while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
cout<}cout<cout<///////////////输出排好的磁道顺序endcout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置////////////////////////////////////////////////////////以下算法确定磁道访问顺序cout<<"磁盘调度顺序为:";if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--){cout<}sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else{while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
cout<cout<///////////////输出排好的磁道顺序endcout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置////////////////////////////////////////////////////////以下算法确定磁道访问顺序cout<<"磁盘调度顺序为:";if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--){cout<}sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else{while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
cout<///////////////输出排好的磁道顺序endcout<<"请输入当前的磁道号:";cin>>now;//确定当前磁头所在位置////////////////////////////////////////////////////////以下算法确定磁道访问顺序cout<<"磁盘调度顺序为:";if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--){cout<}sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else{while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
///////////////输出排好的磁道顺序end
cout<<"请输入当前的磁道号:
cin>>now;//确定当前磁头所在位置
////////////////////////////////////////////////////////以下算法确定磁道访问顺序
if(a[n-1]<=now)//当前磁头位置大于最外围欲访问磁道
for(i=n-1;i>=0;i--)
cout<}sum=now-a[0];}elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else{while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
sum=now-a[0];
elseif(a[0]>=now)//当前磁头位置小于最里欲访问磁道
for(i=0;i{cout<}sum=a[n-1]-now;}else{while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
cout<}sum=a[n-1]-now;}else{while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
sum=a[n-1]-now;
while(a[k]{k++;}l=k-1;///////////////在磁头位置的前一个欲访问磁道r=k;///////////////////////////////磁头欲访问磁道while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
k++;
l=k-1;///////////////在磁头位置的前一个欲访问磁道
r=k;///////////////////////////////磁头欲访问磁道
while((l>=0)&&(r{if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近){cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
if((now-a[l])<=(a[r]-now))//选择离磁头近的磁道(磁头靠左近)
cout<sum+=now-a[l];now=a[l];l=l-1;}else//选择离磁头近的磁道(磁头靠右近){cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
sum+=now-a[l];
now=a[l];
l=l-1;
else//选择离磁头近的磁道(磁头靠右近)
cout<sum+=a[r]-now;now=a[r];r=r+1;}}if(l==-1)//磁头位置里侧的磁道已访问完{for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
sum+=a[r]-now;
now=a[r];
r=r+1;
if(l==-1)//磁头位置里侧的磁道已访问完
for(j=r;j{cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
cout<}sum+=a[n-1]-a[0];}if(r==n)//磁头位置外侧的磁道已访问完{for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道{cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
sum+=a[n-1]-a[0];
if(r==n)//磁头位置外侧的磁道已访问完
for(j=k-1;j>-1;j--)//访问磁头位置里侧的磁道
cout<}sum+=a[n-1]-a[0];}}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
cout<<"移动的总道数:
"<averag=float(sum)/n;cout<<"平均寻道长度:"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
"<}/////////////////////////////////////////////////////////////////////////扫描算法SCANvoidSCAN(inta[],intn){inttemp;intx;floataverag;intk=1;intnow,l,r;inti,j,sum=0;cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
/////////////////////////////////////////////////////////////////////////扫描算法SCAN
voidSCAN(inta[],intn)
intx;
cout<cout<<"扫描算法(SCAN):";///////////////////按磁道递增排序for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
cout<<"扫描算法(SCAN):
///////////////////按磁道递增排序
for(i=0;i{for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
for(j=i+1;j{if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}///////////////////按磁道递增排序end///////////////////输出按磁道递增排序endcout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
///////////////////按磁道递增排序end
///////////////////输出按磁道递增排序end
cout<cout<<"按递增顺序排好的磁道:";for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
for(i=0;i{cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
cout<}cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
cout<cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
cout<cout<<"请输入当前的磁道号:";cin>>now;///////////////////输出按磁道递增排序end////////////////////////////////////////////////////以下算法确定磁道访问顺序if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道{for(i=n-1;i>=0;i--)cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
////////////////////////////////////////////////////以下算法确定磁道访问顺序
if(a[n-1]<=now)//磁头位置大于最外围欲访问磁道
cout<sum=now-a[0];}elseif(a[0]>=now)//磁头位置小于最里欲访问磁道{for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
elseif(a[0]>=now)//磁头位置小于最里欲访问磁道
for(i=0;i{cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
cout<}sum=a[n-1]-now;}else//磁头位置在最里侧磁道与最外侧磁道之间{do{intd;while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
else//磁头位置在最里侧磁道与最外侧磁道之间
intd;
while(a[k]{//确定当前磁道在已排的序列中的位置k++;}l=k-1;//在磁头位置的前一个欲访问磁道r=k;//磁头欲访问磁道cout<<"请选择当前磁头移动的方向(0—向内,1—向外):";cin>>d;//确定磁头访问的方向cout<<"磁盘调度顺序为:";if(d==0||d==1){if(d==0)//磁头向左{for(j=l;j>=0;j--){cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
{//确定当前磁道在已排的序列中的位置
l=k-1;//在磁头位置的前一个欲访问磁道
r=k;//磁头欲访问磁道
cout<<"请选择当前磁头移动的方向(0—向内,1—向外):
cin>>d;//确定磁头访问的方向
if(d==0||d==1)
if(d==0)//磁头向左
for(j=l;j>=0;j--)
cout<}for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
for(j=r;j{cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
cout<}sum=now-2*a[0]+a[n-1];}if(d==1)//磁头向右{for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
sum=now-2*a[0]+a[n-1];
if(d==1)//磁头向右
for(j=r;j{cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
cout<}for(j=l;j>=0;j--){cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
cout<}sum=2*a[n-1]-now-a[0];}cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
sum=2*a[n-1]-now-a[0];
cout<cout<<"移动的总道数:"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
cout<<"移动的总道数:
"<averag=float(sum)/n;cout<<"平均寻道长度:"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
"<cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
cout<<"请选择是否继续测试(任意键—继续0—跳出)"<cin>>x;}elsecout<<"请选择0或1:"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
cin>>x;
cout<<"请选择0或1:
"<}while(x!=0);}} 实验心得:通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。但是不知道具体如何调用到系统里面。
}while(x!
=0);
实验心得:
通过这次实验,我对磁盘管理的算法有进一步的理解而且并不是很难。
但是不知道具体如何调用到系统里面。
copyright@ 2008-2022 冰豆网网站版权所有
经营许可证编号:鄂ICP备2022015515号-1