2. 编写先来先服务算法（FCFS）和扫描算法（SCAN）

先来先服务算法（FCFS）：

先来先服务算法是一种最简单的磁盘调度算法，它按照磁盘请求的到达时间的先后顺序进行调度。

算法步骤如下：
1. 将所有磁盘请求按照到达时间的先后顺序排列；
2. 按照排序后的顺序，依次将磁头移动到每个请求的磁道上，完成读写操作。

实现代码如下：

#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

struct Request {
    int arrive_time; // 到达时间
    int track_number; // 磁道号
};

bool cmp(const Request& r1, const Request& r2) {
    return r1.arrive_time < r2.arrive_time;
}

void FCFS(vector<Request>& requests, int start_track) {
    int total_time = 0;
    int cur_track = start_track;
    for (auto& req : requests) {
        total_time += abs(req.track_number - cur_track);
        cur_track = req.track_number;
    }
    cout << "FCFS: " << total_time << endl;
}

int main() {
    vector<Request> requests = {{0, 50}, {4, 20}, {6, 10}, {7, 30}, {10, 5}};
    int start_track = 30;
    sort(requests.begin(), requests.end(), cmp);
    FCFS(requests, start_track);
    return 0;
}

扫描算法（SCAN）：

扫描算法是一种向一个方向扫描磁盘的算法，它按照磁盘请求的磁道号顺序进行调度，当磁头移动到磁盘的最边缘时，它将立即返回并继续向相反方向扫描，直到扫描完所有的磁盘请求。

算法步骤如下：
1. 将所有磁盘请求按照磁道号的大小进行排序；
2. 假设磁头开始在磁道号较小的一侧，按照排序后的顺序移动磁头，直到扫描到磁盘最边缘；
3. 当磁头移动到磁盘最边缘时，立即返回并继续向相反方向扫描，直到扫描完所有的磁盘请求。

实现代码如下：

#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

struct Request {
    int arrive_time; // 到达时间
    int track_number; // 磁道号
};

bool cmp(const Request& r1, const Request& r2) {
    return r1.track_number < r2.track_number;
}

void SCAN(vector<Request>& requests, int start_track, int direction) {
    int total_time = 0;
    int cur_track = start_track;
    int idx = 0;
    int n = requests.size();
    sort(requests.begin(), requests.end(), cmp);
    for (int i = 0; i < n; i++) {
        if (requests[i].track_number >= start_track) {
            idx = i;
            break;
        }
    }
    if (direction == 1) { // 向磁道号较大的一侧移动
        for (int i = idx; i < n; i++) {
            total_time += abs(requests[i].track_number - cur_track);
            cur_track = requests[i].track_number;
        }
        total_time += abs(cur_track - 199);
        cur_track = 199;
        for (int i = idx - 1; i >= 0; i--) {
            total_time += abs(requests[i].track_number - cur_track);
            cur_track = requests[i].track_number;
        }
    } else { // 向磁道号较小的一侧移动
        for (int i = idx - 1; i >= 0; i--) {
            total_time += abs(requests[i].track_number - cur_track);
            cur_track = requests[i].track_number;
        }
        total_time += abs(cur_track - 0);
        cur_track = 0;
        for (int i = idx; i < n; i++) {
            total_time += abs(requests[i].track_number - cur_track);
            cur_track = requests[i].track_number;
        }
    }
    cout << "SCAN: " << total_time << endl;
}

int main() {
    vector<Request> requests = {{0, 50}, {4, 20}, {6, 10}, {7, 30}, {10, 5}};
    int start_track = 30;
    int direction = 1; // 1表示向磁道号较大的一侧移动，0表示向磁道号较小的一侧移动
    SCAN(requests, start_track, direction);
    return 0;
}