以下是实现上述磁盘调度算法的示例代码，使用了C++11的随机数生成器和命令行参数：
```c++
#include <iostream>
#include <cstdlib>
#include <vector>
#include <algorithm>
#include <random>
#include <cmath>
using namespace std;
// 磁盘请求结构体
struct Request
{
int cylinder; // 磁道号
int arrival_time; // 到达时间
};
// FCFS算法
int fcfs(vector<Request>& requests, int start)
{
int head = start, sum = 0;
for (auto r : requests)
{
sum += abs(head - r.cylinder);
head = r.cylinder;
}
return sum;
}
// SSTF算法
int sstf(vector<Request>& requests, int start)
{
int head = start, sum = 0;
while (!requests.empty())
{
int index = -1, min_dist = INT_MAX;
for (int i = 0; i < requests.size(); i++)
{
int dist = abs(requests[i].cylinder - head);
if (dist < min_dist)
{
min_dist = dist;
index = i;
}
}
sum += min_dist;
head = requests[index].cylinder;
requests.erase(requests.begin() + index);
}
return sum;
}
// SCAN算法
int scan(vector<Request>& requests, int start)
{
int head = start, sum = 0;
vector<Request> left, right;
for (auto r : requests)
{
if (r.cylinder < head)
left.push_back(r);
else
right.push_back(r);
}
sort(left.begin(), left.end(), [](const Request& r1, const Request& r2) { return r1.cylinder > r2.cylinder; });
sort(right.begin(), right.end(), [](const Request& r1, const Request& r2) { return r1.cylinder < r2.cylinder; });
for (auto r : right)
{
sum += abs(head - r.cylinder);
head = r.cylinder;
}
if (!left.empty())
{
sum += abs(head - left.front().cylinder);
head = left.front().cylinder;
for (auto r : left)
{
sum += abs(head - r.cylinder);
head = r.cylinder;
}
}
return sum;
}
// C-SCAN算法
int cscan(vector<Request>& requests, int start)
{
int head = start, sum = 0;
vector<Request> left, right;
for (auto r : requests)
{
if (r.cylinder < head)
left.push_back(r);
else
right.push_back(r);
}
sort(left.begin(), left.end(), [](const Request& r1, const Request& r2) { return r1.cylinder > r2.cylinder; });
sort(right.begin(), right.end(), [](const Request& r1, const Request& r2) { return r1.cylinder < r2.cylinder; });
for (auto r : right)
{
sum += abs(head - r.cylinder);
head = r.cylinder;
}
if (!left.empty())
{
sum += abs(head - 4999);
head = 4999;
for (auto r : left)
{
sum += abs(head - r.cylinder);
head = r.cylinder;
}
}
return sum;
}
// LOOK算法
int look(vector<Request>& requests, int start)
{
int head = start, sum = 0;
vector<Request> left, right;
for (auto r : requests)
{
if (r.cylinder < head)
left.push_back(r);
else
right.push_back(r);
}
sort(left.begin(), left.end(), [](const Request& r1, const Request& r2) { return r1.cylinder > r2.cylinder; });
sort(right.begin(), right.end(), [](const Request& r1, const Request& r2) { return r1.cylinder < r2.cylinder; });
for (auto r : right)
{
sum += abs(head - r.cylinder);
head = r.cylinder;
}
if (!left.empty())
{
sum += abs(head - left.back().cylinder);
head = left.back().cylinder;
for (auto it = left.rbegin(); it != left.rend(); it++)
{
sum += abs(head - it->cylinder);
head = it->cylinder;
}
}
return sum;
}
// C-LOOK算法
int clook(vector<Request>& requests, int start)
{
int head = start, sum = 0;
vector<Request> left, right;
for (auto r : requests)
{
if (r.cylinder < head)
left.push_back(r);
else
right.push_back(r);
}
sort(left.begin(), left.end(), [](const Request& r1, const Request& r2) { return r1.cylinder > r2.cylinder; });
sort(right.begin(), right.end(), [](const Request& r1, const Request& r2) { return r1.cylinder < r2.cylinder; });
for (auto r : right)
{
sum += abs(head - r.cylinder);
head = r.cylinder;
}
if (!left.empty())
{
sum += abs(head - left.back().cylinder);
head = left.back().cylinder;
for (auto it = left.rbegin(); it != left.rend(); it++)
{
sum += abs(head - it->cylinder);
head = it->cylinder;
}
sum += abs(head - right.front().cylinder);
head = right.front().cylinder;
for (auto r : right)
{
sum += abs(head - r.cylinder);
head = r.cylinder;
}
}
return sum;
}
int main(int argc, char* argv[])
{
if (argc < 2)
{
cerr << "用法：disk_sched <start>\n";
return -1;
}
int start = atoi(argv[1]);
vector<Request> requests(1000);
random_device rd;
mt19937 gen(rd());
uniform_int_distribution<> dis(0, 4999);
for (auto& r : requests)
r.cylinder = dis(gen);
sort(requests.begin(), requests.end(), [](const Request& r1, const Request& r2) { return r1.arrival_time < r2.arrival_time; });
cout << "FCFS算法扫描长度为：" << fcfs(requests, start) << endl;
cout << "SSTF算法扫描长度为：" << sstf(requests, start) << endl;
cout << "SCAN算法扫描长度为：" << scan(requests, start) << endl;
cout << "C-SCAN算法扫描长度为：" << cscan(requests, start) << endl;
cout << "LOOK算法扫描长度为：" << look(requests, start) << endl;
cout << "C-LOOK算法扫描长度为：" << clook(requests, start) << endl;
return 0;
}
```
该程序首先从命令行参数中读入磁头的初始位置，然后使用C++11的随机数生成器生成1000个磁盘请求，磁道号随机分布在0到4999之间。接着按照到达时间对请求进行排序，然后依次使用FCFS、SSTF、SCAN、C-SCAN、LOOK和C-LOOK算法对请求进行服务，并输出每种算法的扫描长度。
项目地址: https://gitcode.com/gh_mirrors/al/al-go-rithms 
扫一扫
942
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
