假设磁盘只有一个盘面，并且磁盘是可移动头磁盘。 磁盘是可供多个进程共享的存储设备，但一个磁盘每个时刻只能为一个进程服务。当有进程在访问某个磁盘时，其它想访问该磁盘的进程必须等待，直到磁盘一次工作结束。帮我写一个C语言代码

以下是一个简单的C语言代码示例，模拟了磁盘调度的过程。假设有3个进程需要访问磁盘，磁盘一开始位于磁道50，进程需要访问的磁道分别为40、60、30，代码会根据电梯算法（SCAN）对这些进程进行调度。

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

#define REQUEST_NUM 3     // 进程数
#define START_TRACK 50    // 起始磁道
#define MAX_TRACK 100     // 最大磁道数
#define MIN_TRACK 0       // 最小磁道数
#define UP 1              // 电梯向上
#define DOWN -1           // 电梯向下

// 进程结构体
struct request {
    int track;  // 所需磁道
    int serviced;  // 是否已服务
};

// 电梯结构体
struct elevator {
    int track;  // 当前磁道
    int direction;  // 运行方向
};

// 初始化进程数组
void init_request(struct request *requests) {
    requests[0].track = 40;
    requests[1].track = 60;
    requests[2].track = 30;
    for (int i = 0; i < REQUEST_NUM; i++) {
        requests[i].serviced = 0;
    }
}

// 电梯向上运行
void go_up(struct elevator *elevator) {
    elevator->track++;
}

// 电梯向下运行
void go_down(struct elevator *elevator) {
    elevator->track--;
}

// 打印电梯当前位置
void print_position(struct elevator elevator) {
    printf("Elevator is at track %d\n", elevator.track);
}

// 电梯服务请求
void service_request(struct elevator *elevator, struct request *requests) {
    int serviced = 0;
    while (!serviced) {
        // 电梯向上运行
        while (elevator->direction == UP && elevator->track <= MAX_TRACK) {
            print_position(*elevator);
            for (int i = 0; i < REQUEST_NUM; i++) {
                if (requests[i].serviced == 0 && requests[i].track == elevator->track) {
                    printf("Servicing request %d at track %d\n", i, elevator->track);
                    requests[i].serviced = 1;
                    serviced = 1;
                }
            }
            if (!serviced) {
                go_up(elevator);
            }
        }
        // 电梯向下运行
        while (elevator->direction == DOWN && elevator->track >= MIN_TRACK) {
            print_position(*elevator);
            for (int i = 0; i < REQUEST_NUM; i++) {
                if (requests[i].serviced == 0 && requests[i].track == elevator->track) {
                    printf("Servicing request %d at track %d\n", i, elevator->track);
                    requests[i].serviced = 1;
                    serviced = 1;
                }
            }
            if (!serviced) {
                go_down(elevator);
            }
        }
        // 改变方向
        if (!serviced) {
            elevator->direction = -elevator->direction;
        }
    }
}

int main() {
    struct request requests[REQUEST_NUM];
    struct elevator elevator;
    elevator.track = START_TRACK;
    elevator.direction = UP;
    init_request(requests);
    service_request(&elevator, requests);
    return 0;
}

这个代码使用了电梯算法（SCAN）对进程进行调度，每当电梯到达一个磁道，就会检查是否有进程需要服务，如果有，就服务该进程，直到所有进程都被服务完为止。