移动臂调度算法C++

移动臂调度算法是一种用于磁盘调度的算法，它的目的是为了最大化磁盘的效率，减少寻道时间。下面是一个简单的C++移动臂调度算法示例：

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

int main()
{
    int n, start;
    cin >> n >> start; // 输入磁盘请求队列长度和起始位置
    queue<int> q;
    for (int i = 0; i < n; i++) {
        int x;
        cin >> x;
        q.push(x);
    }
    q.push(start); // 将起始位置也加入请求队列中
    int cur = start, ans = 0;
    while (!q.empty()) {
        int nxt = q.front();
        q.pop();
        ans += abs(nxt - cur); // 累加寻道距离
        cur = nxt; // 更新当前位置
    }
    cout << ans << endl;
    return 0;
}

这个算法的基本思路是，从起始位置开始，每次选择距离最近的磁盘请求进行处理，然后更新当前位置，直到所有请求都被处理完毕。在处理请求的过程中，累加每次寻道的距离，最后输出总的寻道距离。

相关问题

磁盘调度算法c++

磁盘调度算法是操作系统中的一种重要算法，用于调度硬盘上的读写请求。常见的磁盘调度算法有FCFS、SSTF、SCAN、C-SCAN等。以下是一个简单的磁盘调度算法的C++代码示例，仅供参考：

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

// 定义存储磁盘请求的结构体
struct Request {
    int track; // 磁道号
    int time; // 到达时间
};

// FCFS磁盘调度算法
void FCFS(vector<Request>& req, int start) {
    int curr = start; // 当前磁道号
    int total = 0; // 总移动距离
    for (int i = 0; i < req.size(); i++) {
        total += abs(curr - req[i].track);
        curr = req[i].track;
    }
    cout << "FCFS: " << total << endl;
}

// SSTF磁盘调度算法
void SSTF(vector<Request>& req, int start) {
    int curr = start;
    int total = 0;
    while (!req.empty()) {
        int idx = 0, min_dist = INT_MAX;
        for (int i = 0; i < req.size(); i++) {
            int dist = abs(curr - req[i].track);
            if (dist < min_dist) {
                idx = i;
                min_dist = dist;
            }
        }
        total += min_dist;
        curr = req[idx].track;
        req.erase(req.begin() + idx);
    }
    cout << "SSTF: " << total << endl;
}

// SCAN磁盘调度算法
void SCAN(vector<Request>& req, int start, int end) {
    int curr = start;
    int total = 0;
    vector<Request> left, right;
    for (int i = 0; i < req.size(); i++) {
        if (req[i].track < start) left.push_back(req[i]);
        else if (req[i].track > end) right.push_back(req[i]);
        else continue;
    }
    sort(left.begin(), left.end(), [](Request& a, Request& b) { return a.track > b.track; });
    sort(right.begin(), right.end(), [](Request& a, Request& b) { return a.track < b.track; });
    for (int i = 0; i < left.size(); i++) {
        total += abs(curr - left[i].track);
        curr = left[i].track;
    }
    total += end - start;
    curr = end;
    for (int i = 0; i < right.size(); i++) {
        total += abs(curr - right[i].track);
        curr = right[i].track;
    }
    cout << "SCAN: " << total << endl;
}

// C-SCAN磁盘调度算法
void CSCAN(vector<Request>& req, int start, int end) {
    int curr = start;
    int total = 0;
    vector<Request> left, right;
    for (int i = 0; i < req.size(); i++) {
        if (req[i].track < start) left.push_back(req[i]);
        else if (req[i].track > end) right.push_back(req[i]);
        else continue;
    }
    sort(left.begin(), left.end(), [](Request& a, Request& b) { return a.track > b.track; });
    sort(right.begin(), right.end(), [](Request& a, Request& b) { return a.track < b.track; });
    for (int i = 0; i < left.size(); i++) {
        total += abs(curr - left[i].track);
        curr = left[i].track;
    }
    total += end - start;
    curr = end;
    for (int i = 0; i < right.size(); i++) {
        total += abs(curr - right[i].track);
        curr = right[i].track;
    }
    curr = start;
    for (int i = 0; i < left.size(); i++) {
        total += abs(curr - left[i].track);
        curr = left[i].track;
    }
    cout << "C-SCAN: " << total << endl;
}

int main() {
    vector<Request> req { {55, 0}, {58, 3}, {39, 8}, {18, 13}, {90, 17}, {160, 22}, {150, 28}, {38, 39} };
    FCFS(req, 50);
    SSTF(req, 50);
    SCAN(req, 50, 200);
    CSCAN(req, 50, 200);
    return 0;
}

以上代码实现了四种磁盘调度算法：FCFS、SSTF、SCAN、C-SCAN。其中，FCFS算法按照请求的先后顺序依次处理，SSTF算法每次选择离当前磁道号最近的请求，SCAN算法按照磁道号方向依次处理，C-SCAN算法则是在SCAN算法的基础上，将磁道号从尾部到头部再处理一遍。

磁盘调度算法c++代码

以下是一个使用C++实现的磁盘调度算法的示例代码：

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

using namespace std;

// FCFS算法
int fcfs(vector<int>& requests, int start) {
    int total_distance = 0;
    int current_track = start;

    for (int i = 0; i < requests.size(); i++) {
        total_distance += abs(requests[i] - current_track);
        current_track = requests[i];
    }

    return total_distance;
}

// SSTF算法
int sstf(vector<int>& requests, int start) {
    int total_distance = 0;
    int current_track = start;

    while (!requests.empty()) {
        int min_distance = INT_MAX;
        int min_index = -1;

        for (int i = 0; i < requests.size(); i++) {
            int distance = abs(requests[i] - current_track);
            if (distance < min_distance) {
                min_distance = distance;
                min_index = i;
            }
        }

        total_distance += min_distance;
        current_track = requests[min_index];
        requests.erase(requests.begin() + min_index);
    }

    return total_distance;
}

// SCAN算法
int scan(vector<int>& requests, int start, int max_track) {
    int total_distance = 0;
    int current_track = start;
    bool direction = true; // true表示向内移动，false表示向外移动

    while (!requests.empty()) {
        if (current_track == max_track) {
            direction = false;
        } else if (current_track == 0) {
            direction = true;
        }

        if (direction) {
            auto it = find_if(requests.begin(), requests.end(), [current_track](int track) {
                return track >= current_track;
            });

            if (it != requests.end()) {
                total_distance += *it - current_track;
                current_track = *it;
                requests.erase(it);
            } else {
                total_distance += max_track - current_track;
                current_track = max_track;
            }
        } else {
            auto it = find_if(requests.rbegin(), requests.rend(), [current_track](int track) {
                return track <= current_track;
            });

            if (it != requests.rend()) {
                total_distance += current_track - *it;
                current_track = *it;
                requests.erase((it + 1).base());
            } else {
                total_distance += current_track;
                current_track = 0;
            }
        }
    }

    return total_distance;
}

// C-SCAN算法
int cscan(vector<int>& requests, int start, int max_track) {
    int total_distance = 0;
    int current_track = start;

    while (!requests.empty()) {
        auto it = find_if(requests.begin(), requests.end(), [current_track](int track) {
            return track >= current_track;
        });

        if (it != requests.end()) {
            total_distance += *it - current_track;
            current_track = *it;
            requests.erase(it);
        } else {
            total_distance += max_track - current_track;
            current_track = 0;
        }
    }

    return total_distance;
}

int main() {
    vector<int> requests = {98, 138, 37, 122, 14, 124, 65, 67};
    int start_track = 53;
    int max_track = 199;

    int fcfs_distance = fcfs(requests, start_track);
    int sstf_distance = sstf(requests, start_track);
    int scan_distance = scan(requests, start_track, max_track);
    int cscan_distance = cscan(requests, start_track, max_track);

    cout << "FCFS算法平均寻道长度：" << fcfs_distance << endl;
    cout << "SSTF算法平均寻道长度：" << sstf_distance << endl;
    cout << "SCAN算法平均寻道长度：" << scan_distance << endl;
    cout << "C-SCAN算法平均寻道长度：" << cscan_distance << endl;

    return 0;
}