用C语言实现对N个进程采用时间片轮转算法的进程调度

以下是一个使用时间片轮转算法的进程调度C语言实现示例：

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

#define MAX_PROCESS 10
#define TIME_QUANTUM 3

struct Process {
    int pid;
    int burst_time;
    int remaining_time;
};

struct Queue {
    int front, rear, size;
    struct Process processes[MAX_PROCESS];
};

struct Queue createQueue(int size) {
    struct Queue queue;
    queue.front = queue.size = 0;
    queue.rear = size - 1;
    return queue;
}

int isFull(struct Queue *queue) {
    return (queue->size == MAX_PROCESS);
}

int isEmpty(struct Queue *queue) {
    return (queue->size == 0);
}

void enqueue(struct Queue *queue, struct Process process) {
    if (isFull(queue)) {
        printf("Queue is full\n");
        return;
    }
    queue->rear = (queue->rear + 1) % MAX_PROCESS;
    queue->processes[queue->rear] = process;
    queue->size++;
}

struct Process dequeue(struct Queue *queue) {
    if (isEmpty(queue)) {
        struct Process empty_process;
        empty_process.pid = -1;
        empty_process.burst_time = -1;
        empty_process.remaining_time = -1;
        return empty_process;
    }
    struct Process process = queue->processes[queue->front];
    queue->front = (queue->front + 1) % MAX_PROCESS;
    queue->size--;
    return process;
}

void printQueue(struct Queue *queue) {
    printf("Queue: ");
    int i;
    for (i = 0; i < queue->size; i++) {
        printf("%d ", queue->processes[(queue->front + i) % MAX_PROCESS].pid);
    }
    printf("\n");
}

void schedule(struct Process processes[], int n) {
    struct Queue queue = createQueue(n);

    int i;
    for (i = 0; i < n; i++) {
        enqueue(&queue, processes[i]);
    }

    printf("Process execution order: ");
    int time = 0;
    while (!isEmpty(&queue)) {
        struct Process current_process = dequeue(&queue);

        int execution_time = (current_process.remaining_time < TIME_QUANTUM) ? current_process.remaining_time : TIME_QUANTUM;
        current_process.remaining_time -= execution_time;
        time += execution_time;

        printf("%d ", current_process.pid);

        for (i = 0; i < queue.size; i++) {
            struct Process *process = &queue.processes[(queue.front + i) % MAX_PROCESS];
            if (process->remaining_time > 0) {
                process->remaining_time -= execution_time;
            }
        }

        while (1) {
            struct Process next_process = dequeue(&queue);
            if (next_process.pid == -1) {
                break;
            }
            enqueue(&queue, next_process);
        }

        if (current_process.remaining_time > 0) {
            enqueue(&queue, current_process);
        }
    }

    printf("\n");
}

int main() {
    struct Process processes[MAX_PROCESS];
    int n, i;

    printf("Enter number of processes: ");
    scanf("%d", &n);

    for (i = 0; i < n; i++) {
        printf("Enter burst time for process %d: ", i + 1);
        scanf("%d", &processes[i].burst_time);
        processes[i].remaining_time = processes[i].burst_time;
        processes[i].pid = i + 1;
    }

    schedule(processes, n);

    return 0;
}

该程序中，我们使用了一个结构体 `Process` 来表示每个进程，其中包含进程 ID，进程的总执行时间和剩余执行时间。我们还使用了一个结构体 `Queue` 来表示进程队列，其中包含队列的前端、后端以及队列中的进程数量。我们使用 `enqueue` 和 `dequeue` 函数来添加和移除进程。在时间片轮转算法的实现中，我们使用了一个循环来执行进程，每个进程执行一个时间片，如果进程的剩余执行时间大于 0，则将其重新添加到队列中并继续执行下一个进程。