用C实现先来先服务调度算法和短作业优先调度算法

先来先服务调度算法（FCFS）的实现：

#include <stdio.h>

// 进程控制块
typedef struct {
    int id;         // 进程编号
    int arrival;    // 进程到达时间
    int burst;      // 进程运行时间
} PCB;

// 进程队列
typedef struct {
    PCB p[10];      // 进程数组
    int front;      // 队首指针
    int rear;       // 队尾指针
    int size;       // 队列大小
} Queue;

// 初始化队列
void initQueue(Queue *q) {
    q->front = 0;
    q->rear = -1;
    q->size = 0;
}

// 入队
void enqueue(Queue *q, PCB pcb) {
    q->rear++;
    q->p[q->rear] = pcb;
    q->size++;
}

// 出队
PCB dequeue(Queue *q) {
    PCB pcb = q->p[q->front];
    q->front++;
    q->size--;
    return pcb;
}

// 先来先服务调度算法
void fcfs(Queue q) {
    int time = 0;   // 系统时间
    int i;
    PCB pcb;

    for (i = 0; i < q.size; i++) {
        pcb = dequeue(&q);
        // 等待时间 = 当前系统时间 - 进程到达时间
        int wait_time = time - pcb.arrival;
        // 完成时间 = 当前系统时间 + 进程运行时间
        int finish_time = time + pcb.burst;
        // 周转时间 = 完成时间 - 进程到达时间
        int turnaround_time = finish_time - pcb.arrival;
        // 打印进程信息
        printf("Process %d:\n", pcb.id);
        printf("Arrival Time: %d\n", pcb.arrival);
        printf("Burst Time: %d\n", pcb.burst);
        printf("Wait Time: %d\n", wait_time);
        printf("Finish Time: %d\n", finish_time);
        printf("Turnaround Time: %d\n", turnaround_time);
        // 更新系统时间
        time = finish_time;
    }
}

int main() {
    Queue q;
    initQueue(&q);

    PCB p1 = {1, 0, 6};
    PCB p2 = {2, 3, 2};
    PCB p3 = {3, 5, 1};

    enqueue(&q, p1);
    enqueue(&q, p2);
    enqueue(&q, p3);

    fcfs(q);

    return 0;
}

短作业优先调度算法（SJF）的实现：

#include <stdio.h>

// 进程控制块
typedef struct {
    int id;         // 进程编号
    int arrival;    // 进程到达时间
    int burst;      // 进程运行时间
} PCB;

// 进程队列
typedef struct {
    PCB p[10];      // 进程数组
    int front;      // 队首指针
    int rear;       // 队尾指针
    int size;       // 队列大小
} Queue;

// 初始化队列
void initQueue(Queue *q) {
    q->front = 0;
    q->rear = -1;
    q->size = 0;
}

// 入队
void enqueue(Queue *q, PCB pcb) {
    q->rear++;
    q->p[q->rear] = pcb;
    q->size++;
}

// 出队
PCB dequeue(Queue *q) {
    int i, j;
    PCB pcb = q->p[q->front];
    // 将队列中剩余进程按运行时间升序排序
    for (i = q->front+1; i <= q->rear; i++) {
        PCB temp = q->p[i];
        for (j = i-1; j >= q->front && temp.burst < q->p[j].burst; j--) {
            q->p[j+1] = q->p[j];
        }
        q->p[j+1] = temp;
    }
    q->front++;
    q->size--;
    return pcb;
}

// 短作业优先调度算法
void sjf(Queue q) {
    int time = 0;   // 系统时间
    int i;
    PCB pcb;

    for (i = 0; i < q.size; i++) {
        pcb = dequeue(&q);
        // 等待时间 = 当前系统时间 - 进程到达时间
        int wait_time = time - pcb.arrival;
        // 完成时间 = 当前系统时间 + 进程运行时间
        int finish_time = time + pcb.burst;
        // 周转时间 = 完成时间 - 进程到达时间
        int turnaround_time = finish_time - pcb.arrival;
        // 打印进程信息
        printf("Process %d:\n", pcb.id);
        printf("Arrival Time: %d\n", pcb.arrival);
        printf("Burst Time: %d\n", pcb.burst);
        printf("Wait Time: %d\n", wait_time);
        printf("Finish Time: %d\n", finish_time);
        printf("Turnaround Time: %d\n", turnaround_time);
        // 更新系统时间
        time = finish_time;
    }
}

int main() {
    Queue q;
    initQueue(&q);

    PCB p1 = {1, 0, 6};
    PCB p2 = {2, 3, 2};
    PCB p3 = {3, 5, 1};

    enqueue(&q, p1);
    enqueue(&q, p2);
    enqueue(&q, p3);

    sjf(q);

    return 0;
}