操作系统：磁盘调度实现

#include 
#include 
#include 
#include 
using namespace std;

int request[999];//用于记录访问的磁道号
//int request[]{ 30,50,100,180,20,90,150,70,80,10,160,120,40,110 };
 int n = 0;//记录要访问磁道号的数目
queue FCFS_order, SSTF_order, SCAN_order;//记录访问顺序
int FCFS_num = 0, SSTF_num = 0, SCAN_num = 0;//记录移动的总磁道数
int beg_loc ;//前读写头在90号
char beg_direct = '+';//电梯调度算法磁道号移动方向。


//先来先服务算法
void C_FCFS() {
    int b = 0;
    for (int i : request)
    {
        if (i == beg_loc)
        {
            b = 1;
            break;
        }
    }
    if (b == 0)
    {
        FCFS_order.push(beg_loc);
    }
    int loc = beg_loc;
    for (int i = 0; i < n; i++) {
        int tem = request[i];
        FCFS_order.push(tem);
        FCFS_num += abs(loc - tem);
        loc = tem;
    }
}

//最短寻道时间法
void C_SSTF() {
    int b = 0;
    for (int i : request)
    {
        if (i == beg_loc)
        {
            b = 1;
            break;
        }
    }
    if (b == 0)
    {
        SSTF_order.push(beg_loc);
    }
    vector  t(n);
    for (int i = 0; i < n; i++)
        t[i] = request[i];
    sort(t.begin(), t.end());//排序
    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 b = 0;
    for (int i : request)
    {
        if (i == beg_loc)
        {
            b = 1;
            break;
        }
    }
    if (b == 0)
    {
        SCAN_order.push(beg_loc);
    }

    vector  t(n);
    for (int i = 0; i < n; i++)
        t[i] = request[i];
    sort(t.begin(), t.end());//排序
    int nowloc = beg_loc;
    int pre_loc = beg_loc;
    int loc = 0;
    for (int i = 0; i < n; i++)
        if (t[i] >= beg_loc) {
            loc = i;
            break;
        }

    if (beg_direct == '+')
    {
        for (int i = loc; i < n; i++)
        {
            nowloc = t[i];
            SCAN_order.push(t[i]);
            SCAN_num += abs(nowloc - pre_loc);
            pre_loc = nowloc;
        }
        
        for (int i = loc - 1; i >= 0; i--)
        {
            nowloc = t[i];
            SCAN_order.push(t[i]);
            SCAN_num += abs(nowloc - pre_loc);
            pre_loc = nowloc;
        }
    }
    else {
        for (int i = loc-1; i >= 0; i--)
        {
            nowloc = t[i];
            SCAN_order.push(t[i]);
            SCAN_num += abs(nowloc - pre_loc);
            pre_loc = nowloc;
        }
        
        for (int i = loc ; i < n; i++)
        {
            nowloc = t[i];
            SCAN_order.push(t[i]);
            SCAN_num += abs(nowloc - pre_loc);
            pre_loc = nowloc;
        }
    }
    

}
int main()
{
    cout << "请输入需要访问的数量" << endl;
    cin >> n;

    cout << "请依次输入需要访问的磁道" << endl;
    for (int i = 0; i < n; i++)
    {
        cin >> request[i];
    }

    cout << "请输入当前磁头位置" << endl;
    cin >> beg_loc;

    cout << "请输入磁头移动方向" << endl;
    cin >> beg_direct;


    C_FCFS();
    C_SSTF();
    C_SCAN();

    cout << "FCFS总道数" << FCFS_num  << "\t走道顺序:";
    while (FCFS_order.size()) {
        cout << FCFS_order.front() << " ";
        FCFS_order.pop();
    }
    cout << "\nSSTF总道数" << SSTF_num  << "\t走道顺序:";
    while (SSTF_order.size()) {
        cout << SSTF_order.front() << " ";
        SSTF_order.pop();
    }
    cout << "\nSCAN总道数" << SCAN_num  << "\t走道顺序:";
    while (SCAN_order.size()) {
        cout << SCAN_order.front() << " ";
        SCAN_order.pop();
    }

    return 0;
}

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