模拟实现 FCFS、SSTF、电梯 LOOK、C-SCAN 算法，并计算及比较磁头移动道数。1、首先假设磁盘磁道数为 1500，磁头初始位置可任意设置。 2、用随机数生成函数产生“磁道号”序列（即磁盘请求的位置），共产生 400 个。其中 50%位于 0～499，25%分布在 500～999，25%分布在 1000～1499。

好的，我会根据您的要求进行模拟实现 FCFS、SSTF、电梯 LOOK、C-SCAN 算法，并计算及比较磁头移动道数。

首先，我们可以定义一个磁盘请求队列，用于存储随机生成的磁道号序列。然后，我们可以定义一个磁头初始位置，初始位置可以随机生成。

然后，我们可以按照 FCFS、SSTF、电梯 LOOK、C-SCAN 算法的步骤进行模拟实现。

1. FCFS算法

FCFS算法是最简单的磁盘调度算法，按照磁盘请求队列中请求的顺序进行磁头移动。

算法步骤如下：

1. 读取磁盘请求队列中第一个请求的磁道号；
2. 计算磁头移动的距离；
3. 将磁头移动到请求的磁道上，处理该请求；
4. 从磁盘请求队列中删除该请求；
5. 重复执行步骤1~4，直到磁盘请求队列为空。

代码实现如下：

import random

# 随机生成磁道号序列
tracks = []
for i in range(200):
    r = random.random()
    if r < 0.5:
        track = random.randint(0, 499)
    elif r < 0.75:
        track = random.randint(500, 999)
    else:
        track = random.randint(1000, 1499)
    tracks.append(track)

# 随机生成磁头初始位置
head = random.randint(0, 1499)

# FCFS 算法
fcfs_tracks = tracks.copy()
fcfs_head = head
fcfs_distance = 0

while fcfs_tracks:
    track = fcfs_tracks.pop(0)
    fcfs_distance += abs(track - fcfs_head)
    fcfs_head = track

print("FCFS算法磁头移动道数：", fcfs_distance)

2. SSTF算法

SSTF算法选择距离当前磁头最近的磁道进行访问。

算法步骤如下：

1. 找到距离当前磁头最近的磁道号；
2. 计算磁头移动的距离；
3. 将磁头移动到该磁道上，处理该请求；
4. 从磁盘请求队列中删除该请求；
5. 重复执行步骤1~4，直到磁盘请求队列为空。

代码实现如下：

# SSTF 算法
sstf_tracks = tracks.copy()
sstf_head = head
sstf_distance = 0

while sstf_tracks:
    min_distance = float("inf")
    min_index = 0
    for i, track in enumerate(sstf_tracks):
        distance = abs(track - sstf_head)
        if distance < min_distance:
            min_distance = distance
            min_index = i
    track = sstf_tracks.pop(min_index)
    sstf_distance += min_distance
    sstf_head = track

print("SSTF算法磁头移动道数：", sstf_distance)

3. 电梯 LOOK算法

电梯 LOOK算法是一种改进的 SCAN算法，它在到达磁盘的边界时改变方向而不是直接返回。

算法步骤如下：

1. 找到距离当前磁头最近的、方向上的磁道号；
2. 计算磁头移动的距离；
3. 将磁头移动到该磁道上，处理该请求；
4. 从磁盘请求队列中删除该请求；
5. 如果到达磁盘的边界，改变方向；
6. 重复执行步骤1~5，直到磁盘请求队列为空。

代码实现如下：

# 电梯 LOOK 算法
look_tracks = tracks.copy()
look_head = head
look_distance = 0
look_direction = 1  # 1表示向外，-1表示向内

while look_tracks:
    min_distance = float("inf")
    min_index = 0
    for i, track in enumerate(look_tracks):
        if (track - look_head) * look_direction >= 0:
            distance = abs(track - look_head)
            if distance < min_distance:
                min_distance = distance
                min_index = i
    if min_distance == float("inf"):
        look_direction = -look_direction
        continue
    track = look_tracks.pop(min_index)
    look_distance += min_distance
    look_head = track

print("电梯 LOOK 算法磁头移动道数：", look_distance)

4. C-SCAN算法

C-SCAN算法是一种改进的 SCAN算法，它在到达磁盘的边界时直接返回另一端的边界，而不是改变方向。

算法步骤如下：

1. 找到距离当前磁头最近的、方向上的磁道号；
2. 计算磁头移动的距离；
3. 将磁头移动到该磁道上，处理该请求；
4. 从磁盘请求队列中删除该请求；
5. 如果到达磁盘的边界，直接返回另一端的边界；
6. 重复执行步骤1~5，直到磁盘请求队列为空。

代码实现如下：

# C-SCAN 算法
cscan_tracks = tracks.copy()
cscan_head = head
cscan_distance = 0
cscan_direction = 1  # 1表示向外，-1表示向内

while cscan_tracks:
    min_distance = float("inf")
    min_index = 0
    for i, track in enumerate(cscan_tracks):
        if (track - cscan_head) * cscan_direction >= 0:
            distance = abs(track - cscan_head)
            if distance < min_distance:
                min_distance = distance
                min_index = i
    if min_distance == float("inf"):
        cscan_distance += (1500 - cscan_head) if cscan_direction == 1 else cscan_head
        cscan_head = 0 if cscan_direction == 1 else 1499
        cscan_distance += 1500
        cscan_direction = -cscan_direction
        continue
    track = cscan_tracks.pop(min_index)
    cscan_distance += min_distance
    cscan_head = track

print("C-SCAN算法磁头移动道数：", cscan_distance)

运行以上代码，我们可以得到四种算法的磁头移动道数，并进行比较。