帮我用C语言编写具体代码：完成单处理器系统中的进程调度，要求实现时间片轮转、优先数、最短进程优先和最短剩余时间优先四种调度算法。要求能够动态地随机生成5个新进程添加到就绪队列中。模拟程序只对你所设置的“虚拟 PCB”进行相应的调度模拟操作，即每发生“调度”时，显示出当前运行进程的“进程标识符”、“优先数”、“剩余运行时间”等。 主要考虑三个问题：如何组织进程、如何创建进程和如何实现处理器调度。 1、组织进程 考虑如何组织进程，首先要设定进程控制块的内容。进程控制块 PCB 记录各个进程执行时的情况。不同的操作系统，进程控制块记录的信息内容不一样。操作系统功能越强，软 件也越庞大，进程控制块的内容也就越多。这里只使用必不可少的信息。一般操作系统中，无论进程控制块中信息量多少，信息都可以大致分为以下四类：标识信息、说明信息、现场信息、管理信息。可将进程控制块结构定义如下： struct pcb { int name; //进程标识符 int status; //进程状态 int pri; //进程优先数 int time; //剩余运行时间，以时间片为单位，当减至 0 时该进程终止 int next; //下一个进程控制块的位置 } 实验中应该用数组模拟这个 专门的进程控制块区域，定义如下： #define n 10 //假定系统允许进程个数为 n struct pcb pcbarea[n]; //模拟进程控制块区域的数组 实验中指向运行进程的进程控制块指针、就绪队列指针和空闲进程控制块队列指针定义如下： int run; //定义指向正在运行进程的进程控制块的指针 struct { int head; int tail; //定义指向就绪队列的头指针 head 和尾指针 tail }ready; int pfree; //定义指向空闲进程控制块队列的指针

好的，以下是基于你提供的要求，用 C 语言编写的单处理器系统进程调度的代码。该程序实现了时间片轮转、优先数、最短进程优先和最短剩余时间优先四种调度算法，并且能够动态地随机生成5个新进程添加到就绪队列中。每次调度时，程序会显示当前运行进程的进程标识符、优先数和剩余运行时间等信息。

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

struct pcb {
    int name; //进程标识符
    int status; //进程状态
    int pri; //进程优先数
    int time; //剩余运行时间，以时间片为单位，当减至 0 时该进程终止
    int next; //下一个进程控制块的位置
};

#define n 10 //假定系统允许进程个数为 n
struct pcb pcbarea[n]; //模拟进程控制块区域的数组

int run; //定义指向正在运行进程的进程控制块的指针
struct {
    int head;
    int tail; //定义指向就绪队列的头指针 head 和尾指针 tail
} ready;
int pfree; //定义指向空闲进程控制块队列的指针

//初始化就绪队列
void init_ready() {
    ready.head = -1;
    ready.tail = -1;
}

//初始化空闲进程控制块队列
void init_pcbarea() {
    for (int i = 0; i < n; i++) {
        pcbarea[i].status = -1; //表示进程控制块空闲
        pcbarea[i].next = i + 1; //指向下一个空闲进程控制块
    }
    pcbarea[n - 1].next = -1; //最后一个进程控制块指向空
    pfree = 0; //初始化指向空闲进程控制块队列的指针
}

//获取空闲进程控制块
int get_pcb() {
    int i;
    if (pfree == -1) {
        printf("No more PCBs available!\n");
        exit(0);
    }
    else {
        i = pfree;
        pfree = pcbarea[i].next;
    }
    return i;
}

//释放进程控制块
void free_pcb(int i) {
    pcbarea[i].status = -1; //设置进程控制块为空闲状态
    pcbarea[i].next = pfree; //将该进程控制块添加到空闲队列中
    pfree = i;
}

//添加新进程到就绪队列中
void add_process() {
    int i = get_pcb();
    pcbarea[i].name = rand() % 10 + 1; //随机生成进程标识符
    pcbarea[i].status = 0; //设置进程状态为就绪
    pcbarea[i].pri = rand() % 10; //随机生成进程优先数
    pcbarea[i].time = rand() % 5 + 1; //随机生成进程剩余运行时间
    pcbarea[i].next = -1; //新进程控制块的下一个指向空
    if (ready.head == -1) {
        ready.head = i;
        ready.tail = i;
    }
    else {
        pcbarea[ready.tail].next = i;
        ready.tail = i;
    }
}

//打印进程信息
void print_process(int i) {
    printf("Process %d: priority = %d, remaining time = %d\n", pcbarea[i].name, pcbarea[i].pri, pcbarea[i].time);
}

//时间片轮转算法
void rr() {
    if (run != -1) {
        pcbarea[run].time--; //当前正在运行的进程时间片减1
        if (pcbarea[run].time == 0) {
            free_pcb(run); //该进程运行完毕，释放进程控制块
            run = -1; //将当前正在运行的进程指针置为-1
        }
        else { //将当前进程添加到就绪队列尾部
            if (ready.head == -1) {
                ready.head = run;
                ready.tail = run;
            }
            else {
                pcbarea[ready.tail].next = run;
                ready.tail = run;
            }
            run = -1; //将当前正在运行的进程指针置为-1
        }
    }
    if (run == -1 && ready.head != -1) { //如果没有正在运行的进程，但就绪队列非空
        run = ready.head; //将就绪队列队头作为当前运行进程
        ready.head = pcbarea[run].next; //更新就绪队列队头
        if (ready.head == -1) { //如果就绪队列为空
            ready.tail = -1;
        }
        print_process(run); //打印当前运行进程信息
    }
}

//优先数算法
void ps() {
    int max_pri = -1; //记录最高优先数
    int max_pri_proc = -1; //记录具有最高优先数的进程控制块位置
    int prev_proc = -1; //记录当前进程控制块位置的前一个进程控制块位置
    int current_proc = ready.head; //记录当前进程控制块位置
    while (current_proc != -1) { //遍历就绪队列
        if (pcbarea[current_proc].pri > max_pri) { //找到优先数最高的进程
            max_pri = pcbarea[current_proc].pri;
            max_pri_proc = current_proc;
        }
        prev_proc = current_proc;
        current_proc = pcbarea[current_proc].next;
    }
    if (max_pri_proc != -1) { //如果找到优先数最高的进程
        if (run != -1) {
            if (pcbarea[run].pri < max_pri) { //当前进程优先数低于最高优先数
                pcbarea[run].status = 0; //将当前进程状态设置为就绪
                if (prev_proc == -1) {
                    ready.head = pcbarea[run].next;
                }
                else {
                    pcbarea[prev_proc].next = pcbarea[run].next;
                }
                if (pcbarea[run].next == -1) { //当前进程是队尾进程
                    ready.tail = prev_proc;
                }
                pcbarea[run].next = -1; //将当前进程从就绪队列中移除
                current_proc = max_pri_proc; //将优先数最高的进程作为当前运行进程
            }
        }
        else { //没有正在运行的进程
            current_proc = max_pri_proc; //将优先数最高的进程作为当前运行进程
        }
        run = current_proc; //更新当前运行进程指针
        pcbarea[run].status = 1; //将当前进程状态设置为运行
        print_process(run); //打印当前运行进程信息
    }
}

//最短进程优先算法
void sjf() {
    int min_time = 1000; //记录最短运行时间
    int min_time_proc = -1; //记录具有最短运行时间的进程控制块位置
    int prev_proc = -1; //记录当前进程控制块位置的前一个进程控制块位置
    int current_proc = ready.head; //记录当前进程控制块位置
    while (current_proc != -1) { //遍历就绪队列
        if (pcbarea[current_proc].time < min_time) { //找到运行时间最短的进程
            min_time = pcbarea[current_proc].time;
            min_time_proc = current_proc;
        }
        prev_proc = current_proc;
        current_proc = pcbarea[current_proc].next;
    }
    if (min_time_proc != -1) { //如果找到运行时间最短的进程
        if (run != -1) {
            if (pcbarea[run].time > min_time) { //当前进程运行时间长于最短运行时间
                pcbarea[run].status = 0; //将当前进程状态设置为就绪
                if (prev_proc == -1) {
                    ready.head = pcbarea[run].next;
                }
                else {
                    pcbarea[prev_proc].next = pcbarea[run].next;
                }
                if (pcbarea[run].next == -1) { //当前进程是队尾进程