请在以上示例实验程序中补充 SCAN，C-SCAN，LOOK 磁盘移臂调度算法的模 拟程序。

好的，以下是在示例程序中补充 SCAN、C-SCAN 和 LOOK 磁盘移臂调度算法的模拟程序：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 磁盘移臂请求结构体
typedef struct {
    int track; // 磁道号
    int visited; // 是否已访问过
} Request;

// 扫描算法（SCAN）
void scan(Request *reqs, int size, int start, int maxTrack)
{
    int cur = start; // 当前磁道号
    int direction = 1; // 移动方向，1表示向外，-1表示向内
    int totalDist = 0; // 总移动距离

    while (1) {
        int next = -1; // 下一个要访问的磁道号
        int dist = maxTrack; // 当前磁头到下一个要访问的磁道的距离

        // 找到下一个要访问的磁道
        for (int i = 0; i < size; i++) {
            if (!reqs[i].visited) {
                int d = abs(reqs[i].track - cur);
                if (d < dist) {
                    dist = d;
                    next = reqs[i].track;
                }
            }
        }

        // 如果找不到下一个要访问的磁道，则退出循环
        if (next == -1) {
            break;
        }

        // 计算本次移动距离，并更新当前磁道号和总移动距离
        totalDist += dist;
        cur = next;
        reqs[cur].visited = 1;

        // 如果当前磁头到达了最外边或最里边，则改变移动方向
        if (cur == maxTrack || cur == 0) {
            direction = -direction;
        }

        // 按照移动方向继续移动
        cur += direction;
    }

    printf("SCAN 算法总移动距离为：%d\n", totalDist);
}

// 循环扫描算法（C-SCAN）
void cscan(Request *reqs, int size, int start, int maxTrack)
{
    int cur = start; // 当前磁道号
    int totalDist = 0; // 总移动距离

    // 先将所有请求按照磁道号排序
    for (int i = 0; i < size - 1; i++) {
        for (int j = 0; j < size - 1 - i; j++) {
            if (reqs[j].track > reqs[j + 1].track) {
                Request temp = reqs[j];
                reqs[j] = reqs[j + 1];
                reqs[j + 1] = temp;
            }
        }
    }

    // 先按照向外移动的方向扫描磁道
    for (int i = 0; i < size; i++) {
        if (reqs[i].visited || reqs[i].track < start) {
            continue;
        }
        totalDist += abs(reqs[i].track - cur);
        cur = reqs[i].track;
        reqs[i].visited = 1;
    }

    // 再将磁头移动到最里边
    totalDist += cur;
    cur = 0;

    // 最后按照向外移动的方向继续扫描磁道
    for (int i = 0; i < size; i++) {
        if (reqs[i].visited) {
            continue;
        }
        totalDist += abs(reqs[i].track - cur);
        cur = reqs[i].track;
        reqs[i].visited = 1;
    }

    printf("C-SCAN 算法总移动距离为：%d\n", totalDist);
}

// 向内扫描算法（LOOK）
void look(Request *reqs, int size, int start, int maxTrack)
{
    int cur = start; // 当前磁道号
    int direction = 1; // 移动方向，1表示向外，-1表示向内
    int totalDist = 0; // 总移动距离

    // 先将所有请求按照磁道号排序
    for (int i = 0; i < size - 1; i++) {
        for (int j = 0; j < size - 1 - i; j++) {
            if (reqs[j].track > reqs[j + 1].track) {
                Request temp = reqs[j];
                reqs[j] = reqs[j + 1];
                reqs[j + 1] = temp;
            }
        }
    }

    while (1) {
        int next = -1; // 下一个要访问的磁道号
        int dist = maxTrack; // 当前磁头到下一个要访问的磁道的距离

        // 找到下一个要访问的磁道
        for (int i = 0; i < size; i++) {
            if (!reqs[i].visited) {
                int d = abs(reqs[i].track - cur);
                if (d < dist) {
                    dist = d;
                    next = reqs[i].track;
                }
            }
        }

        // 如果找不到下一个要访问的磁道，则退出循环
        if (next == -1) {
            break;
        }

        // 计算本次移动距离，并更新当前磁道号和总移动距离
        totalDist += dist;
        cur = next;
        reqs[cur].visited = 1;

        // 如果当前磁头到达了最外边或最里边，则改变移动方向
        if (cur == maxTrack || cur == 0) {
            direction = -direction;
        }
    }

    printf("LOOK 算法总移动距离为：%d\n", totalDist);
}

int main()
{
    int size, start, maxTrack;
    printf("请输入请求队列大小：\n");
    scanf("%d", &size);

    Request *reqs = (Request *)malloc(size * sizeof(Request));
    memset(reqs, 0, size * sizeof(Request));

    printf("请输入起始磁道号：\n");
    scanf("%d", &start);

    printf("请输入磁盘最大磁道号：\n");
    scanf("%d", &maxTrack);

    printf("请输入%d个磁道号：\n", size);
    for (int i = 0; i < size; i++) {
        scanf("%d", &reqs[i].track);
    }

    // 模拟 SCAN 算法
    Request *reqs1 = (Request *)malloc(size * sizeof(Request));
    memcpy(reqs1, reqs, size * sizeof(Request));
    scan(reqs1, size, start, maxTrack);

    // 模拟 C-SCAN 算法
    Request *reqs2 = (Request *)malloc(size * sizeof(Request));
    memcpy(reqs2, reqs, size * sizeof(Request));
    cscan(reqs2, size, start, maxTrack);

    // 模拟 LOOK 算法
    Request *reqs3 = (Request *)malloc(size * sizeof(Request));
    memcpy(reqs3, reqs, size * sizeof(Request));
    look(reqs3, size, start, maxTrack);

    free(reqs);
    free(reqs1);
    free(reqs2);
    free(reqs3);

    return 0;
}

在上述程序中，我们定义了一个 `Request` 结构体，用于表示磁盘移臂请求。其中 `track` 字段表示请求的磁道号，`visited` 字段表示该请求是否已经被访问过。

然后，我们分别实现了 SCAN、C-SCAN 和 LOOK 三种磁盘移臂调度算法的模拟函数。在这三个函数中，我们依次扫描所有磁盘移臂请求，并计算磁头在移动过程中的总移动距离。

最后，我们在 `main` 函数中读取用户输入的请求队列大小、起始磁道号和最大磁道号，以及所有请求的磁道号，并分别调用 SCAN、C-SCAN 和 LOOK 三个函数进行模拟。