用c实现时间片轮转算法的进程调度程序

好的，下面给您提供一个简单的时间片轮转算法的进程调度程序的C实现，供您参考：

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

// 进程结构体
struct process {
    int pid;  // 进程ID
    int priority;  // 进程优先级
    int burst_time;  // 进程运行时间
    int remaining_time;  // 进程剩余时间
    int arrival_time;  // 进程到达时间
    int waiting_time;  // 进程等待时间
    int turnaround_time;  // 进程周转时间
    int completion_time;  // 进程完成时间
};

int cmp(const void *a, const void *b) {
    return (*(struct process*)a).arrival_time - (*(struct process*)b).arrival_time;
}

int main() {
    int n; // 进程数
    int quantum; // 时间片长度
    struct process *processes; // 进程数组

    // 输入进程数和时间片长度
    printf("请输入进程数和时间片长度：");
    scanf("%d%d", &n, &quantum);

    // 输入每个进程的信息
    processes = (struct process*) malloc(n * sizeof(struct process));
    for (int i = 0; i < n; i++) {
        printf("请输入第%d个进程的信息：", i + 1);
        scanf("%d%d%d", &processes[i].priority, &processes[i].burst_time, &processes[i].arrival_time);
        processes[i].pid = i + 1;
        processes[i].remaining_time = processes[i].burst_time;
    }

    // 按照进程到达时间排序
    qsort(processes, n, sizeof(struct process), cmp);

    int current_time = 0; // 当前时间
    int completed_processes = 0; // 完成的进程数
    int ready_queue[n], front = 0, rear = -1; // 就绪队列

    // 时间片轮转算法
    while (completed_processes < n) {
        // 将到达时间小于等于当前时间的进程加入就绪队列
        while (front <= rear && processes[ready_queue[front]].arrival_time <= current_time) {
            front++;
        }
        for (int i = 0; i < n; i++) {
            if (processes[i].remaining_time > 0 && processes[i].arrival_time <= current_time) {
                int flag = 0;
                for (int j = front; j <= rear; j++) {
                    if (ready_queue[j] == i) {
                        flag = 1;
                        break;
                    }
                }
                if (!flag) {
                    rear++;
                    ready_queue[rear] = i;
                }
            }
        }

        if (front > rear) { // 如果就绪队列为空，直接跳过
            current_time++;
            continue;
        }

        int p_idx = ready_queue[front]; // 取出队首进程
        front++;

        // 计算等待时间和周转时间
        processes[p_idx].waiting_time += current_time - processes[p_idx].completion_time;
        processes[p_idx].turnaround_time += current_time - processes[p_idx].arrival_time + processes[p_idx].waiting_time;

        // 如果进程剩余时间小于等于时间片长度，直接运行到完成
        if (processes[p_idx].remaining_time <= quantum) {
            current_time += processes[p_idx].remaining_time;
            processes[p_idx].completion_time = current_time;
            processes[p_idx].remaining_time = 0;
            completed_processes++;
        } else { // 否则运行一个时间片长度
            current_time += quantum;
            processes[p_idx].remaining_time -= quantum;
            processes[p_idx].completion_time = current_time;
            rear++;
            ready_queue[rear] = p_idx; // 放回就绪队列
        }
    }

    // 输出结果
    double total_waiting_time = 0, total_turnaround_time = 0;
    for (int i = 0; i < n; i++) {
        total_waiting_time += processes[i].waiting_time;
        total_turnaround_time += processes[i].turnaround_time;
        printf("进程%d：等待时间=%d 周转时间=%d\n", processes[i].pid, processes[i].waiting_time, processes[i].turnaround_time);
    }
    printf("平均等待时间：%.2f\n", total_waiting_time / n);
    printf("平均周转时间：%.2f\n", total_turnaround_time / n);

    free(processes);
    return 0;
}

以上就是一个简单的时间片轮转算法的进程调度程序的C实现，希望能对您有所帮助。