用c语言写进程的四种调度算法以及主函数的调用

C语言中常见的进程调度算法包括：先来先服务（FCFS）、最短作业优先（SJF）、时间片轮转（RR）和优先级调度（PS）。

1. 先来先服务（FCFS）调度算法：

FCFS算法是最简单的进程调度算法，当有多个进程等待运行时，按照它们的到达时间顺序依次执行。具体实现可以通过按照进程到达时间先后将进程按顺序加入一个队列中，然后依次执行队列中的进程。

2. 最短作业优先（SJF）调度算法：

SJF算法是根据进程的执行时间来进行调度的，即优先选择执行时间最短的进程。具体实现可以将所有进程按照执行时间从小到大排列，然后依次执行。

3. 时间片轮转（RR）调度算法：

RR算法是一种基于时间片的调度算法，每个进程被分配一个时间片，当时间片用完后，该进程被暂停并放入队列的末尾，等待下一次调度。具体实现可以通过一个循环队列来实现，每个进程执行一个时间片后，将其放到队列的末尾，然后执行下一个进程。

4. 优先级调度（PS）调度算法：

PS算法是根据进程的优先级来进行调度的，即优先选择优先级最高的进程。具体实现可以将所有进程按照优先级从高到低排列，然后依次执行。

下面是一个主函数的调用示例：

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

// 进程结构体
typedef struct {
    int pid;    // 进程ID
    int arrive; // 到达时间
    int burst;  // 执行时间
    int priority;   // 优先级
} Process;

// 先来先服务调度算法
void fcfs(Process *procs, int n) {
    int time = 0;
    for (int i = 0; i < n; i++) {
        printf("执行进程 %d，开始时间 %d，结束时间 %d\n", procs[i].pid, time, time + procs[i].burst);
        time += procs[i].burst;
    }
}

// 最短作业优先调度算法
void sjf(Process *procs, int n) {
    // 按照执行时间从小到大排序
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            if (procs[j].burst < procs[i].burst) {
                Process tmp = procs[i];
                procs[i] = procs[j];
                procs[j] = tmp;
            }
        }
    }
    // 执行进程
    int time = 0;
    for (int i = 0; i < n; i++) {
        printf("执行进程 %d，开始时间 %d，结束时间 %d\n", procs[i].pid, time, time + procs[i].burst);
        time += procs[i].burst;
    }
}

// 时间片轮转调度算法
void rr(Process *procs, int n, int quantum) {
    // 循环队列的实现
    int front = 0, rear = 0;
    Process *queue = (Process *)malloc(sizeof(Process) * n);
    int *time_left = (int *)malloc(sizeof(int) * n);
    for (int i = 0; i < n; i++) {
        time_left[i] = procs[i].burst;
    }
    queue[rear++] = procs[0];
    int time = 0;
    while (front != rear) {
        Process cur = queue[front];
        front = (front + 1) % n;
        if (time_left[cur.pid] > quantum) {
            time += quantum;
            time_left[cur.pid] -= quantum;
            queue[rear++] = cur;
        } else {
            time += time_left[cur.pid];
            printf("执行进程 %d，开始时间 %d，结束时间 %d\n", cur.pid, time - time_left[cur.pid], time);
            for (int i = 0; i < n; i++) {
                if (procs[i].arrive <= time && time_left[i] > 0) {
                    int flag = 0;
                    for (int j = front; j != rear; j = (j + 1) % n) {
                        if (queue[j].pid == i) {
                            flag = 1;
                            break;
                        }
                    }
                    if (flag == 0) {
                        queue[rear++] = procs[i];
                    }
                }
            }
        }
    }
    free(queue);
    free(time_left);
}

// 优先级调度算法
void ps(Process *procs, int n) {
    // 按照优先级从高到低排序
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            if (procs[j].priority > procs[i].priority) {
                Process tmp = procs[i];
                procs[i] = procs[j];
                procs[j] = tmp;
            }
        }
    }
    // 执行进程
    int time = 0;
    for (int i = 0; i < n; i++) {
        printf("执行进程 %d，开始时间 %d，结束时间 %d\n", procs[i].pid, time, time + procs[i].burst);
        time += procs[i].burst;
    }
}

int main() {
    // 初始化进程
    Process procs[] = {
        {0, 0, 5, 2},
        {1, 1, 3, 1},
        {2, 2, 2, 3},
        {3, 3, 4, 4},
        {4, 4, 1, 5}
    };
    int n = 5;

    // 先来先服务调度算法
    printf("先来先服务调度算法：\n");
    fcfs(procs, n);

    // 最短作业优先调度算法
    printf("最短作业优先调度算法：\n");
    sjf(procs, n);

    // 时间片轮转调度算法
    printf("时间片轮转调度算法：\n");
    rr(procs, n, 2);

    // 优先级调度算法
    printf("优先级调度算法：\n");
    ps(procs, n);

    return 0;
}