cscan演算法

㈠ fifo sstf scan cscan 哪個效率最高

這是一種先進先出置換演算法(first in first out-fifo)，該演算法總是淘汰最先進入主存的頁面，即選擇主存中駐留時間最久的頁面給予淘汰。

㈡ 操作系統的題目，求大神解答

低級題，
目前最新是固態硬碟，晶元控制的，不必考慮的是磁頭當前的移動方向。

循環掃描演算法（CSCAN）
SCAN演算法既能獲得較好的尋道性能，又能防止「飢餓」現象，故被廣泛用於大、中、小型機器和網路中的磁碟調度。但SCAN也存在這樣的問題：當磁頭剛從里向外移動而越過了某一磁軌時，恰好又有一進程請求訪問此磁軌，這時，該進程必須等待，待磁頭繼續從里向外，然後再從外向里掃描完所有要訪問的磁軌後，才處理該進程的請求，致使該進程的請求被大大地推遲。

㈢ 我需要用C++程序做的Nstep-scan

自己看著修改了，修改下還不簡單。

#include "stdio.h"
#include "stdlib.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+ 平均尋道長度:*%0.2f* ",Aver);
}
if (t==1) printf("\n+ 磁軌由內向外移動");
else printf("\n+ 磁軌由外向內移動");
return(Han);
}
//循環掃描演算法(CSCAN)
void CSCAN(int Han,int DiscL[])
{

int j,h,n,Temp,m,k,All,Last,i;
int RLine[10]; //將隨機生成的磁軌數數組Discl[]復制給數組RLine[]
int Min;
int tmp=0;
m=2;
k=9;
All=0; //統計全部的磁軌數變數
Last=Han;
CopyL(DiscL,RLine,9); //復制磁軌號到臨時數組RLine
printf("\n+ 按照CSCAN演算法磁軌的訪問順序為:");
while (k>=0)
{
for (j=0;j<=9;j++) //從當前磁軌號開始，由內向外搜索離當前磁軌最近的磁軌號
{
h=-1;
Min=64000;
for (n=0;n<=k;n++)
{
if (RLine[n]>=Han)
{
Temp=RLine[n]-Han;
if (Temp<Min)
{
Min=Temp;
h=n;
}
}
}
if (h!=-1)
{
All=All+Min; //統計一共移動的距離
printf("%5d",RLine[h]);
Han=RLine[h];
Last=RLine[h];
DelInq(RLine,h,k);
k--;
}
}
if (k>=0)
{
tmp=RLine[0];
for (i=0;i<k;i++)//算出剩下磁軌號的最小值
{
if (tmp>RLine[i]) tmp=RLine[i];
}
Han=tmp;//把最小的磁軌號賦給Han
Temp=Last-tmp;//求出最大磁軌號和最小磁軌號的距離差
All=All+Temp;
}
}
Best[Jage][1]=All;//Best[][1]存放移動磁軌數
Best[Jage][0]=4;//Best[][0]存放演算法的序號為:4
Jage++;//排序序號加1
Aver=((float)All)/10;//求平均尋道次數
printf("\n+ 移動磁軌數:<%5d> ",All);
printf("\n+ 平均尋道長度:*%0.2f* ",Aver);
}
//N步掃描演算法(NStepScan)
void N_Step_SCAN(int Han1,int DiscL[])
{
int i,m,k;
int RLine1[10];
NAll=0;
m=2;
k=9; //限定10個的磁軌數
i=-1;
CopyL(DiscL,RLine1,9); //復制磁軌號到臨時數組RLine
printf("\n+ 按照N_Step_SCAN演算法磁軌的訪問順序為:");
for (m=0;m<2;m++) //由於限定10磁軌數，將10個磁軌數分為兩組，每組5個磁軌數，每個組按照SCAN演算法執行，該循環循環2次
{
Han1=SCAN(Han1,RLine1,i+1,i+5);
i=i+5;
}
Best[Jage][1]=NAll;//Best[][1]存放移動磁軌數
Best[Jage][0]=5;//Best[][0]存放演算法的序號為:5
Aver=((float)NAll)/10;//求平均尋道次數
printf("\n+ 移動磁軌數:<%5d> ",NAll);
printf("\n+ 平均尋道長度:*%0.2f* ",Aver);
}
//尋道長度由低到高排序
void PaiXu()
{
int i,j,Temp;
for (i=0;i<5;i++)
{
for (j=0;j<4;j++)
{
if (Best[j][1]>Best[j+1][1]) //如果前一個演算法的移動磁軌距離大於後一個移動磁軌數，執行下面語句
{
Temp=Best[j+1][1]; //從這起下三行執行冒泡法將移動距離大小排序，排完後則執行每個演算法的排序
Best[j+1][1]=Best[j][1];
Best[j][1]=Temp;
Temp=Best[j+1][0]; //將每個演算法的序號用冒泡法排序
Best[j+1][0]=Best[j][0];
Best[j][0]=Temp;
}
}
}
}

㈣ 習題精編上 磁碟尋到演算法中的LOOK 和 C_LOOK 是啥意思啊

LOOK 和 C_LOOK 分別是回看的掃描和循環掃描，它與scan ,cscan不通之處是scan掃描是要回到磁軌最外出或最里處才返回，而LOOK只需要到達要訪問的磁軌最外或最里處就會返回。比如磁軌1—1000，分別要訪問150,300,800道的內容，那如果現在在500磁軌，向磁軌小的方向訪問的話，scan 演算法會移到磁軌1後再返回，LOOK演算法移到磁軌150或就會返回了了。同理 C_LOOK 與cscan的不同之處類似

㈤ 目前常用的磁碟調度演算法有哪幾種每種演算法優先考慮的問題是什麼

(1)先來先服務(FCFS，First-Come First-Served)
此演算法根據進程請求訪問磁碟的先後次序進行調度。
(2)最短尋道時間優先(SSTF ，ShortestSeekTimeFirst)
該演算法選擇這樣的進程，其要求訪問的磁軌與當前磁頭所在的磁軌距離最近，以使每次的尋道時間最短，但這種調度演算法卻不能保證平均尋道時間最短。
(3)掃描(SCAN)演算法
SCAN演算法不僅考慮到欲訪問的磁軌與當前磁軌的距離，更優先考慮的是磁頭的當前移動方向。
(4)循環掃描(CSCAN)演算法
CSCAN演算法規定磁頭單向移動，避免了掃描演算法導致的某些進程磁碟請求的嚴重延遲。
(5) N-Step-SCAN和FSCAN調度演算法
1) N-Step-SCAN演算法。為克服前述SSTF、SCAN、CSCAN等調度演算法都可能出現的磁臂停留在某處不動的情況即磁臂粘著現象，將磁碟請求隊列分成若干個長度為N的子隊列，按先來先服務演算法依次處理這些子隊列，而各隊列分別以掃描演算法進行處理。
2) FSCAN演算法
FSCAN演算法實質上是N步SCAN演算法的簡化。它只將磁碟請求訪問隊列分成兩個子隊列。一是當前所有請求磁碟I/O的進程形成的隊列，由磁碟調度按SCAN演算法進行處理。另一個隊列則是在 掃描期間，新出現的所有請求磁碟I/O進程的隊列，放入另一等待處理的請求隊列。這樣，所有的新請求都將被推遲到下一次掃描時處理。

㈥ 磁碟調度演算法有哪幾種

磁碟調度在多道程序設計的計算機系統中，各個進程可能會不斷提出不同的對磁碟進行讀/寫操作的請求。由於有時候這些進程的發送請求的速度比磁碟響應的還要快，因此我們有必要為每個磁碟設備建立一個等待隊列，常用的磁碟調度演算法有以下四種：[1]
先來先服務演算法（FCFS），
最短尋道時間優先演算法（SSTF），
掃描演算法（SCAN），
循環掃描演算法（CSCAN）

㈦ 請幫我把這個C語言小程序改為C++的，通過了追加分70+20一定給

#include <stdio.h>

void main()
{
char algorithm;
float l,m;
int a[100];
int direct,begin,i,j,t,k,n=0;
printf("請輸入要調度序列的個數：\n");
scanf("%d",&n);
printf("請輸入要調度的序列：\n");
for(i=0;i<n;i++)
{
scanf("%d",&a[i]);
}
printf("\n");
for(i=0;i<n-2;i++)
{
for(j=n-1;j>=1;j--)
{
if(a[j]<a[j-1])
{
t=a[j];
a[j]=a[j-1];
a[j-1]=t;
}
}
}
/* for(i=0;i<n;i++)
cout<<a[i]<<endl;*/
printf("請選擇磁碟調度演算法,其中s代表scan演算法，c代表cscan演算法:\n");
//cin>>algorithm;
scanf("%c",&algorithm);
//以下為scan演算法實現磁碟調度
if(algorithm=='s')
{

printf("請輸入開始的磁碟序列號：\n");
scanf("%d",&begin);
printf("\n");
for(i=0;i<n;i++)
{
if(a[i]==begin)
k=i;
}

printf("請輸入訪問方向,其中1為增大方向，0為減小方向：\n");
scanf("%d",&direct);
printf("\n");
m=float(n)-1;
if(direct==1)
{
for(i=k;i<n;i++)
//cout<<a[i]<<" ";
printf("%d ",a[i]);
for(i=k-1;i>=0;i--)
//cout<<a[i]<<" ";
printf("%d ",a[i]);
//cout<<endl;
printf("\n");
l=((a[n-1]-a[k])+(a[n-1]-a[0]))/m;
//cout<<"平均尋道長度為："<<l<<endl;
printf("平均尋道長度為：%d\n",l);

}
else
{
for(i=k;i>=0;i--)
//cout<<a[i]<<" ";
printf("%d ",a[i]);
for(i=k+1;i<n;i++)
printf("%d ",a[i]);
printf("\n");
l=((a[k]-a[0])+(a[n-1]-a[0]))/m;
printf("平均尋道長度為：%d\n",l);
}
}
//以下為cscan演算法實現調度
else
{
//cout<<"請輸入開始的磁碟序列號："<<endl;
printf("請輸入開始的磁碟序列號：\n");
//cin>>begin;
// cout<<endl;
scanf("%d",&begin);
printf("\n");
for(i=0;i<n;i++)
{
if(a[i]==begin)
k=i;
}
//cout<<"請輸入訪問方向,其中1為增大方向，0為減小方向："<<endl;
printf("請輸入訪問方向,其中1為增大方向，0為減小方向：\n");
//cin>>direct;
//cout<<endl;
scanf("%d",&direct);
printf("\n");
m=float(n)-1;
if(direct==1)
{
for(i=k;i<n;i++)
printf("%d ",a[i]);
for(i=0;i<k;i++)
printf("%d ",a[i]);
printf("\n");
l=((a[n-1]-a[k])+(a[n-1]-a[0])+(a[k-1]-a[0]))/m;
printf("平均尋道長度為：%d\n",l);
}
else
{
for(i=k;i>=0;i--)
printf("%d ",a[i]);
for(i=n-1;i>k;i--)
printf("%d ",a[i]);
printf("\n");
l=((a[k]-a[0])+(a[n-1]-a[0])+(a[n-1]-a[k+1]))/m;
printf("平均尋道長度為：%d\n",l);
}
}

}

㈧ scan與cscan有什麼異同

CSCAN美國Horner公司開發的一種通信網路，採用Controller Area Network技術。
循環掃描CSCAN（Circular SCAN）

為了減少SCAN演算法造成的某些進程的請求被嚴重推遲，CSCAN演算法規定磁頭單向移動。

㈨ 請教關於磁碟調度的問題，到底按照哪種方法來啊

嗯，是問的這個問題我看的答案是大綱後面的答案，2010年第45題，為方便大家看，我把部分題目寫在下面某計算機系統採用CSCAN（循環掃描）磁碟調度策略，使用2KB的內存空間記錄16384個磁碟塊的空閑狀態，某單面磁碟旋轉速度為每分鍾6000轉，每個磁軌有100個扇區，相鄰磁軌間的平均移動時間為1ms。在某時刻，磁頭位於100號磁軌處，並沿著磁軌增大的方向移動，磁軌號請求隊列是50，90，30，120答案給出的磁軌移動時間是170ms（沒給過程），那就應該是按照100->120->30->50->90的順序來移動的了說明CSCAN演算法 不移動到頭，移動到請求的磁軌即可，並且返回到最小的磁軌時的移動時間也要計算但是我在有的輔導書上看到的是說，不計算返回時間剛翻了下課本，湯小丹的操作系統第三版196頁，根據敘述和例子，意思是說不用移動到頭，只到請求的最大磁軌，並且返回到請求的最小磁軌的時間需要計算而關於SCAN演算法，課本上也是說只移動到請求的最大磁軌而我在文×都的輔導書上看到的，關於SCAN演算法還特地強調了要移動到頭，甚至根據磁碟扇區的數目和每磁軌的扇區數計算出總磁軌數再計算移動時間，真是糾結啊

㈩ 計算機試卷求解

假設磁頭當前位於第105道,正在向磁軌序號增加的方向移動,現有一個磁軌訪問請求序列為35,45,12,68,110,180,170,195,採用SCAN調度(電梯調度)算得到的