先宣告一下全域性變數

int initPosition,maxSize,numTrack;//磁頭所在位置，磁碟所能盛放的最大磁軌數目，要訪問的磁軌數
int cost;//磁頭總移動距離
vector<int> Track;//要訪問的磁軌們
vector<int> Result;//整理好的訪問磁軌的順序

vector<int>sorted_Track;//把要訪問 磁軌順序從小到大整理好

1.FCFS  First Come First Sever   先來先服務

示例：

程式碼思路：先來先服務

void FCFS(){
    Result.clear();
    cost=abs(Track[0]-initPosition);
for (int i=0;i<Track.size()-1;i++){
        cost=cost+abs(Track[i+1]-Track[i]);
}
Result=Track;
cout<<"FCFS"<<endl;
Print_Results();//列印結果的
}
 

2. SSTF shortest seek time first  最短訪問時間優先

就是在我所有的要訪問的磁道里，我先訪問理我目前位置最近的。

示例：

程式碼思路：

先從大到小排序，在排好序了的要訪問的佇列裡，先找離自己最近的，訪問之後，再找左右兩個位置裡離自己最近的位置。

程式碼實現：

    1.排序

    2.找到裡自己最近的一個，push入Result

   3.從該節點開始，與左、右 位置進行做差對比。

        if左邊不存在或者右邊不存在了，就把剩下整個排序佇列push進result裡

void SSTF(){
    Result.clear();
    vector<int> sorted_Track;
    sorted_Track.push_back(Track[0]);
    int tag=0;
    for(int i=1;i<Track.size();i++){
        tag=0;
        for(int j=0;j<sorted_Track.size();j++){
            if(Track[i]<sorted_Track[j]){
                sorted_Track.insert(sorted_Track.begin()+j,Track[i]);
                tag=1;
                break;
            }
        }
        if(tag==0){
            sorted_Track.push_back(Track[i]);
        }
    }

    int min=maxSize;
    int position=0;
    for(int i=0;i<sorted_Track.size();i++){
        if(abs(sorted_Track[i]-initPosition)<min){
            min=abs(sorted_Track[i]-initPosition);
            position=i;
        }
    }

    int temp1;
    int temp2;
    while(sorted_Track.size()!=0){
        if(position!=0&&position!=sorted_Track.size()-1){
            temp1=abs(sorted_Track[position-1]-sorted_Track[position]);
            temp2=abs(sorted_Track[position+1]-sorted_Track[position]);
            if(temp1<=temp2){
                Result.push_back(sorted_Track[position]);
                sorted_Track.erase(sorted_Track.begin()+position);
                position=position-1;
            }else{
                Result.push_back(sorted_Track[position]);
                sorted_Track.erase(sorted_Track.begin()+position);
            }
        }else if(position==0){
            for(int k=0;k<sorted_Track.size();k++){
                Result.push_back(sorted_Track[k]);
            }
            sorted_Track.clear();
        }else if(position==sorted_Track.size()-1){
             for(int k=sorted_Track.size()-1;k>=0;k--){
                Result.push_back(sorted_Track[k]);
            }
            sorted_Track.clear();
        }
    }
    calculate();//用來算cost的
    cout<<"SSTF"<<endl;
    Print_Results();
}
 

3. SCAN aka Elevator Algorithm  aka電梯演算法

磁頭選定一個方向，會一直朝那個方向移動，直到那個方向再沒有磁軌。之後再反方向順序移動。一般是從外往裡掃，（從大往小），這裡是規定掃到0.

例子：

程式碼示例：

void SCAN(){
    Result.clear();
    cost=0;
    sort_algo();//用來求sorted_Track的，排序從小到大
    int position=0;
    for(int i=0;i<sorted_Track.size();i++){
        if(sorted_Track[i]>initPosition){
            if(i>=1){
                position=i-1;
            }else{
                position=0;
            }
            break;
        }
    }
    for(int i=position;i>=0;i--){
        Result.push_back(sorted_Track[i]);
    }
    Result.push_back(0);
    for(int i=position+1;i<sorted_Track.size();i++){
        Result.push_back(sorted_Track[i]);
    }
    calculate();
    cout<<"SCAN"<<endl;
    Print_Results();
}
 

4. C-SCAN Restricts scanning to one direction only 僅限制掃描到一個方向

一直朝著一個方向走，比如從某個位置走到0，再一下子訪問最後一個，再從外往裡掃掃到完成全部的磁軌（不需要回到原來的位置）。

示例：

程式碼：

void CSCAN(){
    Result.clear();
    cost=0;
    int position=0;
    for(int i=0;i<sorted_Track.size();i++){
        if(sorted_Track[i]>initPosition){
            if(i>=1){
                position=i-1;
            }else{
                position=0;
            }
            break;
        }
    }
    for(int i=position;i>=0;i--){
        Result.push_back(sorted_Track[i]);
    }
    Result.push_back(0);
    Result.push_back(maxSize-1);
    for(int i=sorted_Track.size()-1;i>position;i--){
        Result.push_back(sorted_Track[i]);
    }
   cost=initPosition-0;
   cost=cost+maxSize-1-sorted_Track[position+1];
    cout<<"C-SCAN"<<endl;
    Print_Results();
}

5.  LOOK   SCAN的增強版

朝裡（0）掃，掃到頭再返回方向，與SCAN不同的是它這次不用非得到0，到最小的那個需求就可以了。

程式碼其實就比SCAN少一行，Result沒有Push進0：

void LOOK(){
    Result.clear();
    cost=0;
    int position=0;
    for(int i=0;i<sorted_Track.size();i++){
        if(sorted_Track[i]>initPosition){
            if(i>=1){
                position=i-1;
            }else{
                position=0;
            }
            break;
        }
    }
    for(int i=position;i>=0;i--){
        Result.push_back(sorted_Track[i]);
    }
    for(int i=position+1;i<sorted_Track.size();i++){
        Result.push_back(sorted_Track[i]);
    }
    
   cost=initPosition+sorted_Track[sorted_Track.size()-1]-sorted_Track[0]-sorted_Track[0];
    cout<<"LOOK"<<endl;
    Print_Results();
}

6.  C-LOOK  C-SCAN的增強版

堅持同一個方向往裡掃。

與LOOK對於SCAN的改動相同，也是沒有到0，也不用從最後來，第二次掃描從最後一個需求開始就好；

示例：

程式碼：

void CLOOK(){
Result.clear();
    cost=0;
    int position=0;
    for(int i=0;i<sorted_Track.size();i++){
        if(sorted_Track[i]>initPosition){
            if(i>=1){
                position=i-1;
            }else{
                position=0;
            }
            break;
        }
    }
    for(int i=position;i>=0;i--){
        Result.push_back(sorted_Track[i]);
    }
    
    for(int i=sorted_Track.size()-1;i>position;i--){
        Result.push_back(sorted_Track[i]);
    }

   cost=initPosition-sorted_Track[0];
   cost=cost+sorted_Track[sorted_Track.size()-1]-sorted_Track[position+1];
    cout<<"C-LOOK"<<endl;
    Print_Results();
}