操作系统 先来先服务算法（FCFS）最短寻到时间优先算法（SSTF）扫描算法（电梯算法，SCAN）循环扫描算法（CSCAN）

Posted 2021-10-01 来老铁干了这碗代码

操作系统 先来先服务算法（FCFS）、最短寻到时间优先算法（SSTF）、扫描算法（电梯算法，SCAN）、循环扫描算法（CSCAN）和N步扫描算法（NStepScan）的程序实现

复制到本地即可运行

#include "stdio.h"
#include "stdlib.h"
#include "conio.h"

void CopyL(int Sour[],int Dist[] ,int x); //数组Sour复制到数组Dist，复制到x个数
void SetDI(int DiscL[]);  //随机生成磁道数  
void Print(int Pri[],int x);  //打印输出数组Pri
void DelInq(int Sour[],int x,int y);  //数组Sour把x位置的数删除，并把y前面的数向前移动，y后的数保持不变(即会出现2个y) 
void FCFS(int Han,int DiscL[]);  //先来先服务算法(FCFS)
void SSTF(int Han,int DiscL[]);  //最短寻道时间优先算法(SSTF)
int SCAN(int Han,int DiscL[],int x,int y);  //扫描算法(SCAN)
void CSCAN(int Han,int DiscL[]);  //循环扫描算法(CSCAN)
void N_Step_SCAN(int Han1,int DiscL[]);  //N步扫描算法(NStepScan)
void PaiXu();  //寻道长度由低到高排序
void Pri();
int NAll=0;
int Best[5][2]; //用作寻道长度由低到高排序时存放的数组 
int Limit=0; //输入寻找的范围磁道数i
int Jage;
float Aver=0;

int main()
{
 int i;
 int DiscLine[10];  //声明准备要生成的随机磁道号的数组
 int Hand;  //磁道数
 int Con=1;
 int n;
 while(Con==1)
 {
  Jage=0;
  printf("\\n 请输入初始的磁道数(0<n<65536):");
     scanf("%d",&Hand);
   printf("\\n+ 输入寻找的范围:");
  scanf("%d",&Limit);
  if(Limit>65536){
   printf("超出范围!");
  } 
  else{
    printf("               ╭═══════════════╮            \\n");
    printf("               ║       操作系统课程设计       ║    \\n");
 printf("   ╭═════┤         磁盘调度算法         ├═════╮\\n");
 printf("   ║          ║                              ║          ║\\n");
 printf("   ║          ╰═══════════════╯          ║\\n");
 printf("　 ║               1.先来先服务算法(FCFS)                 ║\\n");
 printf("   ║                                                      ║\\n");
  printf("   ║               2.最短寻道时间优先算法(SSTF)           ║\\n");
  printf("   ║                                                      ║\\n");
   printf("   ║               3.扫描算法(SCAN)                       ║\\n");
  printf("   ║                                                      ║\\n");
  printf("   ║               4.循环扫描算法(CSCAN)                  ║\\n");
  printf("   ║                                                      ║\\n");
  printf("   ║               5.N步扫描算法(NStepScan)               ║\\n");
  printf("   ║                                                      ║\\n");
   printf("   ║               6.各类算法的比较                       ║\\n");
 printf("   ║                                                      ║\\n");
  printf("   ║                                                      ║\\n");
 printf("   ║  ╭───────────────────────╮  ║\\n");
  printf("   ╰═┤        请输入你的选择的算法(输入0离开)       ├═╯\\n");
    printf("       ╰───────────────────────╯\\n");
 scanf("%d",&n);
 if(n==0) exit(0);
 printf("\\n");
 switch(n)
 {
 case 1:
  SetDI(DiscLine);  //随机生成磁道数
  FCFS(Hand,DiscLine); //先来先服务算法(FCFS)
  break;
 case 2:
  SetDI(DiscLine);  //随机生成磁道数
  SSTF(Hand,DiscLine); //最短寻道时间优先算法(SSTF)
  break;
 case 3:
  SetDI(DiscLine);  //随机生成磁道数
  SCAN(Hand,DiscLine,0,9);  //扫描算法(SCAN)
  break;
 case 4:
        SetDI(DiscLine);  //随机生成磁道数
  CSCAN(Hand,DiscLine); //循环扫描算法(CSCAN)   
  break;
 case 5:
        SetDI(DiscLine);  //随机生成磁道数
  N_Step_SCAN(Hand,DiscLine);  //N步扫描算法(NStepScan)
  break;
 case 6:
  SetDI(DiscLine);  //随机生成磁道数
  FCFS(Hand,DiscLine); //先来先服务算法(FCFS)
  SSTF(Hand,DiscLine); //最短寻道时间优先算法(SSTF)
  SCAN(Hand,DiscLine,0,9); //扫描算法(SCAN)
  CSCAN(Hand,DiscLine);  //循环扫描算法(CSCAN)
  N_Step_SCAN(Hand,DiscLine);  //N步扫描算法(NStepScan)
  PaiXu();  //寻道长度由低到高排序
  printf("\\n\\n+ 寻道长度由低到高排序:"); 
  for(i=0;i<5;i++)
  {
   printf("%4d ",Best[i][0]);
  }
  break;
 }
  printf("\\n\\n+ 是否继续(按0结束,按1继续)?");
  scanf("%5d",&Con);
  }

  }
}

//数组Sour复制到数组Dist，复制到x个数
void CopyL(int Sour[],int Dist[] ,int x)
{
 int i;
 for(i=0;i<=x;i++)
 {
  Dist[i]=Sour[i];
 }
}
//打印输出数组Pri
void Print(int Pri[],int x)
{
 int i;
 for(i=0;i<=x;i++)
 {
  printf("%5d",Pri[i]);
 }
}
//随机生成磁道数
void SetDI(int DiscL[])
{
 int i;
 for(i=0;i<=9;i++)
    {
  DiscL[i]=rand()%Limit;//随机生成10个磁道号
 }
 printf("+ 需要寻找的磁道号:");
 Print(DiscL,9);  //输出随机生成的磁道号
 printf("\\n");
}
//数组Sour把x位置的数删除，并把y前面的数向前移动，y后的数保持不变(即会出现2个y) 
void DelInq(int Sour[],int x,int y)
{
 int i;
 for(i=x;i<y;i++)
 { 
  Sour[i]=Sour[i+1];
  x++;
 }
}
//先来先服务算法(FCFS)
void FCFS(int Han,int DiscL[])
{
 int RLine[10];  //将随机生成的磁道数数组Discl[]复制给数组RLine[]
 int i,k,All,Temp;  //Temp是计算移动的磁道距离的临时变量
 All=0;  //统计全部的磁道数变量
 k=9;  //限定10个的磁道数
 CopyL(DiscL,RLine,9);  //复制磁道号到临时数组RLine
    printf("\\n+ 按照FCFS算法磁道的访问顺序为:");
 All=Han-RLine[0];
 for(i=0;i<=9;i++)
 {
  Temp=RLine[0]-RLine[1];//求出移动磁道数,前一个磁道数减去后一个磁道数得出临时的移动距离
  if(Temp<0) 
   Temp=(-Temp);//移动磁道数为负数时,算出相反数作为移动磁道数
  printf("%5d",RLine[0]);
  All=Temp+All;//求全部磁道数的总和 
  DelInq(RLine,0,k);//每个磁道数向前移动一位
  k--;
 }
 Best[Jage][1]=All;//Best[][1]存放移动磁道数 
 Best[Jage][0]=1; //Best[][0]存放算法的序号为:1 
 Jage++;//排序的序号加1
 Aver=((float) All)/10;//求平均寻道次数 
 printf("\\n+ 移动磁道数:<%5d> ",All);
 printf("\\n+ 平均寻道长度:*%0.2f* ",Aver);
}
//最短寻道时间优先算法(SSTF)
void SSTF(int Han,int DiscL[])
{
 int i,j,k,h,All;
 int Temp;  //Temp是计算移动的磁道距离的临时变量
 int RLine[10];   //将随机生成的磁道数数组Discl[]复制给数组RLine[]
 int Min;
 All=0;  //统计全部的磁道数变量
 k=9;  //限定10个的磁道数
 CopyL(DiscL,RLine,9);  //复制磁道号到临时数组RLine
    printf("\\n+ 按照SSTF算法磁道的访问顺序为:");
 for(i=0;i<=9;i++)
 {
        Min=64000;
  for(j=0;j<=k;j++) //内循环寻找与当前磁道号最短寻道的时间的磁道号 
  {
   if(RLine[j]>Han)  //如果第一个随机生成的磁道号大于当前的磁道号，执行下一句
    Temp=RLine[j]-Han;  //求出临时的移动距离
   else
    Temp=Han-RLine[j];  //求出临时的移动距离
   if(Temp<Min)  //如果每求出一次的移动距离小于Min，执行下一句
   {
    Min=Temp;  //Temp临时值赋予Min
    h=j;  //把最近当前磁道号的数组下标赋予h
   }
  }
  All=All+Min;  //统计一共移动的距离
  printf("%5d",RLine[h]);
  Han=RLine[h];  
  DelInq(RLine,h,k);  //每个磁道数向前移动一位
  k--;
 }
 Best[Jage][1]=All;//Best[][1]存放移动磁道数 
 Best[Jage][0]=2;//Best[][0]存放算法的序号为:2
 Jage++;//排序序号加1
 Aver=((float)All)/10;//求平均寻道次数 
 printf("\\n+ 移动磁道数:<%5d> ",All);
 printf("\\n+ 平均寻道长度:*%0.2f* ",Aver);
}
//扫描算法(SCAN)
int SCAN(int Han,int DiscL[],int x,int y)
{
    int j,n,k,h,m,All;
 int t=0;
 int Temp;
 int Min;
 int RLine[10]; //将随机生成的磁道数数组Discl[]复制给数组RLine[] 
 int Order;
 Order=1;
 k=y;
 m=2;  //控制while语句的执行，即是一定要使当前磁道向内向外都要扫描到
 All=0;  //统计全部的磁道数变量
 CopyL(DiscL,RLine,9);  //复制磁道号到临时数组RLine
    printf("\\n+ 按照SCAN算法磁道的访问顺序为:");
 Min=64000;
 for(j=x;j<=y;j++)  //寻找与当前磁道号最短寻道的时间的磁道号
 {
  if(RLine[j]>Han)  //如果第一个随机生成的磁道号大于当前的磁道号，执行下一句
   Temp=RLine[j]-Han;  //求出临时的移动距离
  else
   Temp=Han-RLine[j];  //求出临时的移动距离
  if(Temp<Min)
  {
   Min=Temp;  //Temp临时值赋予Min
   h=j;   //把最近当前磁道号的数组下标赋予h
  }
 }
 All=All+Min;  
    printf("%5d",RLine[h]);
 if(RLine[h]>=Han){  //判断磁道的移动方向，即是由里向外还是由外向里
  Order=0;
  t=1;
 }
 Han=RLine[h];
 DelInq(RLine,h,k);  //每个磁道数向前移动一位
 k--;
 while(m>0)  
 {
  if(Order==1)  //order是判断磁盘扫描的方向标签，order是1的话，磁道向内移动
  {
   for(j=x;j<=y;j++)  
   {
    h=-1;
    Min=64000;
    for(n=x;n<=k;n++)  //判断离当前磁道最近的磁道号
    {
     if(RLine[n]<=Han)
     {
      Temp=Han-RLine[n];
                if(Temp<Min)
      {
       Min=Temp;  //Temp临时值赋予Min
                h=n;  //把最近当前磁道号的数组下标赋予h
      }
     }
    }
    if(h!=-1)
    {
     All=All+Min;  //叠加移动距离
     printf("%5d",RLine[h]);
     Han=RLine[h]; //最近的磁道号作为当前磁道
     DelInq(RLine,h,k);
     k--;
    }
   }
   Order=0;  //当完成向内的移动，order赋予0，执行else语句，使磁道向外移动
      m--;  //向内完成一次，m减一次，保证while循环执行两次
  }
  else  //order是0的话，磁道向外移动
  {
   for(j=x;j<=y;j++)
   {
    h=-1;
    Min=64000;
    for(n=x;n<=k;n++)  //判断离当前磁道最近的磁道号
    {
     if(RLine[n]>=Han)
     {
      Temp=RLine[n]-Han;
                if(Temp<Min)
      {
       Min=Temp;   //Temp临时值赋予Min
                   h=n;  //把最近当前磁道号的数组下标赋予h
      }
     }
    }
    if(h!=-1)
    {
     All=All+Min;  //叠加移动距离
     printf("%5d",RLine[h]);
     Han=RLine[h];  //最近的磁道号作为当前磁道
     DelInq(RLine,h,k);
     k--;
    }
   }
   Order=1;  //当完成向内的移动，order赋予0，执行else语句，使磁道向外移动
      m--;   //向内完成一次，m减一次，保证while循环执行两次
  }
 }
 NAll=NAll+All;
 if((y-x)>5)
 {
  Best[Jage][1]=All;//Best[][1]存放移动磁道数 
  Best[Jage][0]=3;//Best[][0]存放算法的序号为:3
  Jage++;//排序序号加1
  Aver=((float)All)/10;//求平均寻道次数 
  printf("\\n+ 移动磁道数:<%5d> ",All);
  printf("\\n+ 平均寻道长
以上是关于操作系统 先来先服务算法（FCFS）最短寻到时间优先算法（SSTF）扫描算法（电梯算法，SCAN）循环扫描算法（CSCAN）的主要内容，如果未能解决你的问题，请参考以下文章
 
 16.磁盘调度
 磁盘调度算法
 操作系统实验报告磁盘管理实验
 调度算法先来先服务（FCFS）最短作业优先（SJF）和最高响应比优先（HRRN）算法
 磁盘调度算法FCFSSSTFSCANCSCAN详解
 磁盘调度算法