写出c语言代码实现完成单处理器系统中的进程调度，要求实现时间片轮转、优先数、最短进程优 先和最短剩余时间优先四种调度算法。实验具体包括：首先确定进程控制块的内容，进程控 制块的组成方式；然后完成进程创建原语和进程调度原语；最后编写主函数对所作工作进行 测试。 模拟程序只对你所设置的“虚拟 PCB”进行相应的调度模拟操作，即每发生“调度” 时，显示出当前运行进程的“进程标识符”、“优先数”、“剩余运行时间”等，而不需要对系 统中真正的 PCB 等数据进行修改。首先建立一个就绪队列，随机生成信息建立若 干个进程；然后进行进程调度；将正在运行进程指针指向的进程控制块的内容以及调度一次 后进程队列的现状输出，查看结果。题目要求模拟实现四种调度方法，优先数调度 要求动态改变优先数，假设大数代表高优先级，进程每运行一次优先数就减“1”，即被 调度时执行：优先数－1，剩余运行时间－1，来模拟进程的一次运行。 进程运行一次后，若剩余运行时间不等于 0，则再将它加入队列（按优先数大小插入， 且置队首标志）；若剩余运行时间等于 0，则把它的状态修改成“终止”，且退出队列。 若就绪进程队列不为空，则重复调度，直到所有进程都“终止”。

以下是一个简单的 C 语言程序实现，包括进程控制块的定义、进程创建和调度原语的实现、以及主函数测试：

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

// 进程控制块
typedef struct PCB {
    int pid;                // 进程标识符
    int priority;           // 优先数
    int remaining_time;     // 剩余运行时间
    struct PCB *next;       // 指向下一个 PCB 的指针
} PCB;

// 全局变量
PCB *ready_queue = NULL;    // 就绪队列

// 创建新的 PCB
PCB* create_process(int pid, int priority, int remaining_time) {
    PCB *new_process = (PCB*)malloc(sizeof(PCB));
    new_process->pid = pid;
    new_process->priority = priority;
    new_process->remaining_time = remaining_time;
    new_process->next = NULL;
    return new_process;
}

// 将 PCB 插入就绪队列中（按优先数从大到小排序）
void insert_into_ready_queue(PCB *new_process) {
    PCB *current_process = ready_queue;
    PCB *previous_process = NULL;
    while (current_process != NULL && current_process->priority >= new_process->priority) {
        previous_process = current_process;
        current_process = current_process->next;
    }
    if (previous_process == NULL) {
        new_process->next = ready_queue;
        ready_queue = new_process;
    } else {
        previous_process->next = new_process;
        new_process->next = current_process;
    }
}

// 从就绪队列中移除 PCB
void remove_from_ready_queue(PCB *process) {
    if (process == ready_queue) {
        ready_queue = process->next;
    } else {
        PCB *current_process = ready_queue;
        while (current_process != NULL && current_process->next != process) {
            current_process = current_process->next;
        }
        if (current_process != NULL) {
            current_process->next = process->next;
        }
    }
    free(process);
}

// 时间片轮转调度算法
void round_robin_scheduling(int time_slice) {
    PCB *current_process = ready_queue;
    if (current_process == NULL) {
        printf("No process in ready queue.\n");
        return;
    }
    // 执行当前进程的时间片
    printf("Running process %d (priority: %d, remaining time: %d)\n", 
           current_process->pid, current_process->priority, current_process->remaining_time);
    current_process->remaining_time -= time_slice;
    // 如果进程还未完成，则将其移动到队列尾部
    if (current_process->remaining_time > 0) {
        remove_from_ready_queue(current_process);
        insert_into_ready_queue(current_process);
    } else {    // 进程已经完成，从队列中移除
        remove_from_ready_queue(current_process);
        printf("Process %d has finished.\n", current_process->pid);
    }
}

// 优先数调度算法
void priority_scheduling() {
    PCB *current_process = ready_queue;
    if (current_process == NULL) {
        printf("No process in ready queue.\n");
        return;
    }
    // 执行当前进程
    printf("Running process %d (priority: %d, remaining time: %d)\n", 
           current_process->pid, current_process->priority, current_process->remaining_time);
    current_process->remaining_time--;
    current_process->priority--;
    // 如果进程还未完成，则将其重新插入队列（按优先数从大到小排序）
    if (current_process->remaining_time > 0) {
        remove_from_ready_queue(current_process);
        insert_into_ready_queue(current_process);
    } else {    // 进程已经完成，从队列中移除
        remove_from_ready_queue(current_process);
        printf("Process %d has finished.\n", current_process->pid);
    }
}

// 最短进程优先调度算法
void shortest_job_first_scheduling() {
    PCB *current_process = ready_queue;
    if (current_process == NULL) {
        printf("No process in ready queue.\n");
        return;
    }
    // 选择剩余运行时间最短的进程
    PCB *shortest_process = current_process;
    while (current_process != NULL) {
        if (current_process->remaining_time < shortest_process->remaining_time) {
            shortest_process = current_process;
        }
        current_process = current_process->next;
    }
    // 执行当前进程
    printf("Running process %d (priority: %d, remaining time: %d)\n", 
           shortest_process->pid, shortest_process->priority, shortest_process->remaining_time);
    shortest_process->remaining_time--;
    // 如果进程还未完成，则将其重新插入队列
    if (shortest_process->remaining_time > 0) {
        remove_from_ready_queue(shortest_process);
        insert_into_ready_queue(shortest_process);
    } else {    // 进程已经完成，从队列中移除
        remove_from_ready_queue(shortest_process);
        printf("Process %d has finished.\n", shortest_process->pid);
    }
}

// 最短剩余时间优先调度算法
void shortest_remaining_time_first_scheduling() {
    PCB *current_process = ready_queue;
    if (current_process == NULL) {
        printf("No process in ready queue.\n");
        return;
    }
    // 选择剩余运行时间最短的进程
    PCB *shortest_process = current_process;
    while (current_process != NULL) {
        if (current_process->remaining_time < shortest_process->remaining_time) {
            shortest_process = current_process;
        }
        current_process = current_process->next;
    }
    // 执行当前进程
    printf("Running process %d (priority: %d, remaining time: %d)\n", 
           shortest_process->pid, shortest_process->priority, shortest_process->remaining_time);
    shortest_process->remaining_time--;
    // 如果进程还未完成，则将其重新插入队列
    if (shortest_process->remaining_time > 0) {
        remove_from_ready_queue(shortest_process);
        insert_into_ready_queue(shortest_process);
    } else {    // 进程已经完成，从队列中移除
        remove_from_ready_queue(shortest_process);
        printf("Process %d has finished.\n", shortest_process->pid);
    }
}

// 主函数
int main() {
    // 随机创建若干个进程并加入就绪队列
    srand(time(NULL));
    int process_count = rand() % 10 + 1;
    for (int i = 0; i < process_count; i++) {
        int pid = i + 1;
        int priority = rand() % 10;
        int remaining_time = rand() % 10 + 1;
        PCB *new_process = create_process(pid, priority, remaining_time);
        insert_into_ready_queue(new_process);
    }
    // 模拟进程调度
    while (ready_queue != NULL) {
        printf("Ready queue: ");
        PCB *current_process = ready_queue;
        while (current_process != NULL) {
            printf("%d(%d,%d) ", current_process->pid, current_process->priority, current_process->remaining_time);
            current_process = current_process->next;
        }
        printf("\n");
        // 时间片轮转调度
        round_robin_scheduling(3);
        // 优先数调度
        priority_scheduling();
        // 最短进程优先调度
        shortest_job_first_scheduling();
        // 最短剩余时间优先调度
        shortest_remaining_time_first_scheduling();
    }
    return 0;
}