磁盘调度算法（先来先服务、最短寻道优先以及电梯调度算法）

背景：磁盘调度

题目描述

• 1、对于如下给定的一组磁盘访问进行调度：
  请求服务到达 A B C D E F G H I J K L M N
  访问的磁道号 30 50 100 180 20 90 150 70 80 10 160 120 40 110

请求服务到达	A	B	C	D	E	F	G	H	I	J	K	L	M	N
访问的磁道号	30	50	100	180	20	90	150	70	80	10	160	120	40	110

• 2、要求分别采用先来先服务、最短寻道优先以及电梯调度算法进行调度。
• 3、要求给出每种算法中磁盘访问的顺序，计算出平均移动道数。
• 4、假定当前读写头在90号，电梯调度算法向磁道号增加的方向移动。

算法设计

先来先服务算法（FCFS）:

按访问请求到达的先后次序服务。

最短寻道时间优先算法（SSTF）:

优先选择距当前磁头最近的访问请求进行服务

扫描算法（电梯算法）（SCAN）:

当有访问请求时，磁头按一个方向移动，在移动过程中对遇到的访问请求进行服务，然后判断该方向上是否还有访问请求，如果有则继续扫描；否则改变移动方向，并为经过的访问请求服务，如此反复。

代码实现

感谢支持

#include <iostream>
#include <queue>
#include <cmath>
using namespace std;

int request[]{30,50,100,180,20,90,150,70,80,10,160,120,40,110};
const int n = 14;
queue<int> FCFS_order, SSTF_order, SCAN_order;
//queue<int> FCFS_move, SSTF_move, SCAN_move;
int FCFS_num = 0, SSTF_num = 0, SCAN_num = 0;
int beg_loc = 90;//前读写头在90号
char beg_direct = '+';//电梯调度算法向磁道号增加的方向移动。


void C_FCFS() {
    int loc = beg_loc;
    for (int i = 0; i < n; i++) {
        int tem = request[i];
        FCFS_order.push(tem);
       // FCFS_move.push(abs(loc - tem));
        FCFS_num += abs(loc - tem);
        loc = tem;
    }
}
void C_SSTF() {
    int t[n];
    for (int i = 0; i < n; i++)
        t[i] = request[i];
    sort(t, t + n);//排序
    int loc = beg_loc;
    int pre_loc = beg_loc;
    for (int j = 0; j < n; j++){
        int min_dis = 9999;
        int tem = 0;
        for (int i = 0; i < n; i++){
            if (abs(t[i] - loc) < min_dis)
                min_dis = abs(t[i] - loc), tem = i;
        }
        loc = t[tem];
        SSTF_order.push(loc);
        SSTF_num += abs(t[tem] - pre_loc);
        pre_loc = loc;
        t[tem] = 99999;
    }
}
void C_SCAN() {
    int t[n];
    for (int i = 0; i < n; i++)
        t[i]= request[i];
    sort(t,t+n);//排序
    int loc = 0;
    for (int i = 0; i < n; i++) 
        if (t[i] >= beg_loc) {
            loc = i;
            break;
        }
    for (int i = loc; i < n; i++) {
        SCAN_order.push(t[i]);
        SCAN_num += abs(t[i] - t[i-1]);
    }
   // SCAN_num-= abs(t[loc] - t[loc - 1]);//初始位置没有移动
    SCAN_num += abs(t[n-1] - t[loc - 1]);//转头回来
    for (int i = loc-1; i >= 0; i--) {
        SCAN_order.push(t[i]);
        SCAN_num += abs(t[i] - t[i + 1]);
    }

}
int main()
{
    C_FCFS();        
    C_SSTF();    
    C_SCAN();

    cout << "FCFS平均" << (double)FCFS_num / n << "\t顺序:";
    while (FCFS_order.size()) {
        cout << FCFS_order.front() << " ";
        FCFS_order.pop();
    }
    cout << "\nSSTF平均" << (double)SSTF_num / n << "\t顺序:";
    while (SSTF_order.size()) {
        cout << SSTF_order.front() << " ";
        SSTF_order.pop();
    }
    cout << "\nSCAN平均" << (double)SCAN_num / n << "\t顺序:";
    while (SCAN_order.size()) {
        cout << SCAN_order.front() << " ";
        SCAN_order.pop();
    }

    return 0;
}

/*
先来先服务算法（FCFS）:按访问请求到达的先后次序服务。
最短寻道时间优先算法（SSTF）:优先选择距当前磁头最近的访问请求进行服务
扫描算法（电梯算法）（SCAN）:
    当有访问请求时，磁头按一个方向移动，在移动过程中对遇到的访问请求进行服务，
    然后判断该方向上是否还有访问请求，如果有则继续扫描；
    否则改变移动方向，并为经过的访问请求服务，如此反复。

*/

运行结果