scan演算法實現

❶ scan掃描演算法要到端嗎

scan掃描演算法要到端。掃描演算法（SCAN）也叫電梯演算法。只有磁頭移動到最外側磁軌時才能往內移動，移動到最內側磁軌的時候才能往外移動。

❷ 求磁碟調度演算法scan演算法的java代碼

1、先來先服務演算法（FCFS）First Come First Service
這是一種比較簡單的磁碟調度演算法。它根據進程請求訪問磁碟的先後次序進行調度。此演算法的優點是公平、簡單，且每個進程的請求都能依次得到處理，不會出現某一進程的請求長期得不到滿足的情況。此演算法由於未對尋道進行優化，在對磁碟的訪問請求比較多的情況下，此演算法將降低設備服務的吞吐量，致使平均尋道時間可能較長，但各進程得到服務的響應時間的變化幅度較小。
先來先服務 （125）86.147.91.177.94.150.102.175.130

[java] view plain print?

❸ 在磁碟調度，sstf演算法中，為什麼說：總是選擇最小尋找時間並不能保證平均尋找時間最小

FCFS演算法根據進程請求訪問磁碟的先後順序進行調度，這是一種最簡單的調度演算法。該演算法的優點是具有公平性。如果只有少量進程需要訪問，且大部分請求都是訪問簇聚的文件扇區，則有望達到較好的性能；但如果有大量進程競爭使用磁碟，那麼這種演算法在性能上往往接近於隨機調度。所以，實際磁碟調度中考慮一些更為復雜的調度演算法。
1、演算法思想：按訪問請求到達的先後次序服務。
2、優點：簡單，公平。
3、缺點：效率不高，相鄰兩次請求可能會造成最內到最外的柱面尋道，使磁頭反復移動，增加了服務時間，對機械也不利。
4、例子：
假設磁碟訪問序列：98，183，37，122，14，124，65，67。讀寫頭起始位置：53。求：磁頭服務序列和磁頭移動總距離（道數）。
由題意和先來先服務演算法的思想，得到下圖所示的磁頭移動軌跡。由此：
磁頭服務序列為：98，183，37，122，14，124，65，67
磁頭移動總距離=（98-53）+（183-98）+|37-183|+（122-37）+|14-122|+（124-14）+|65-124|+（67-65）=640（磁軌） SSTF演算法選擇調度處理的磁軌是與當前磁頭所在磁軌距離最近的磁軌，以使每次的尋找時間最短。當然，總是選擇最小尋找時間並不能保證平均尋找時間最小，但是能提供比FCFS演算法更好的性能。這種演算法會產生「飢餓」現象。
1、演算法思想：優先選擇距當前磁頭最近的訪問請求進行服務，主要考慮尋道優先。
2、優點：改善了磁碟平均服務時間。
3、缺點：造成某些訪問請求長期等待得不到服務。
4、例子：對上例的磁碟訪問序列，可得磁頭移動的軌跡如下圖。 SCAN演算法在磁頭當前移動方向上選擇與當前磁頭所在磁軌距離最近的請求作為下一次服務的對象。由於磁頭移動規律與電梯運行相似，故又稱為電梯調度演算法。SCAN演算法對最近掃描過的區域不公平，因此，它在訪問局部性方面不如FCFS演算法和SSTF演算法好。
演算法思想：當設備無訪問請求時，磁頭不動；當有訪問請求時，磁頭按一個方向移動，在移 動過程中對遇到的訪問請求進行服務，然後判斷該方向上是否還有訪問請求，如果有則繼續掃描；否則改變移動方向，並為經過的訪問請求服務，如此反復。如下圖所示：
掃描演算法（電梯演算法）的磁頭移動軌跡
2、優點：克服了最短尋道優先的缺點，既考慮了距離，同時又考慮了方向。 在掃描演算法的基礎上規定磁頭單向移動來提供服務，回返時直接快速移動至起始端而不服務任何請求。由於SCAN演算法偏向於處理那些接近最里或最外的磁軌的訪問請求，所以使用改進型的C-SCAN演算法來避免這個問題。
釆用SCAN演算法和C-SCAN演算法時磁頭總是嚴格地遵循從盤面的一端到另一端，顯然，在實際使用時還可以改進，即磁頭移動只需要到達最遠端的一個請求即可返回，不需要到達磁碟端點。這種形式的SCAN演算法和C-SCAN演算法稱為LOOK和C-LOOK調度。這是因為它們在朝一個給定方向移動前會查看是否有請求。注意，若無特別說明，也可以默認SCAN演算法和C-SCAN演算法為LOOK和C-LOOK調度。

❹ 電腦技術 操作系統 LOOK SCAN演算法

C-LOOK=10到5到90到80到70到60到20=160
C-SCAN=10到5到0到199到90到80到70到60到20=388
LOOK=10到5到20到60到70到80到90=90
SCAN=10到5到0到20到60到70到80到90=100

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

(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進程的隊列，放入另一等待處理的請求隊列。這樣，所有的新請求都將被推遲到下一次掃描時處理。

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

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

❼ 電梯演算法是怎樣的

電梯演算法是通過操作系統學術名為SCAN演算法。磁臂僅移動到請求的最外道就回轉。反方向查找服務。

如果請求調度的磁軌為98, 183, 37, 122, 14, 124, 65, 67，磁頭從53號磁軌開始移動，磁頭就會按照65, 67, 98, 122, 124, 183, 37,14 的順序依次查找，並將數據輸入內存。

電梯（升降盒）上下來回地運動，電梯內部有一些按鈕，每一個按鈕代表一層樓，當按下按鈕時，按鈕的燈亮。

電梯沿某一方向運動，在將要到達某一層樓時，實時監控器 判斷電梯內是否有乘客要在此層樓下電梯，若有，則發送信號給電梯升降架。

電梯是指服務於建築物內若干特定的樓層，其轎廂運行在至少兩列垂直於水平面或與鉛垂線傾斜角小於15°的剛性軌道運動的永久運輸設備。

也有台階式，踏步板裝在履帶上連續運行，俗稱自動扶梯或自動人行道。服務於規定樓層的固定式升降設備。垂直升降電梯具有一個轎廂，運行在至少兩列垂直的或傾斜角小於15°的剛性導軌之間。

轎廂尺寸與結構形式便於乘客出入或裝卸貨物。習慣上不論其驅動方式如何，將電梯作為建築物內垂直交通運輸工具的總稱。

❽ 求計算機操作系統的高手幫做一個題(急得很啊）

移動順序:223.198.176.156.149.142.136.245
共移動總量
8
僅做參考千萬莫模仿有恐誤人子弟

❾ 我需要用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;
}
}
}
}