优先级调度算法c语言

优先级调度算法是一种基于进程优先级的调度算法，它将处理器分配给具有最高优先级的进程，如果有多个进程具有相同的最高优先级，则采用先来先服务的原则。

以下是一个简单的使用优先级调度算法的 C 语言代码示例：

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

#define MAX_PROCESS 5

typedef struct {
    int pid;
    int priority;
    int burst_time;
} Process;

void swap(Process *a, Process *b) {
    Process temp = *a;
    *a = *b;
    *b = temp;
}

void sort(Process processes[], int n) {
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            if (processes[i].priority < processes[j].priority) {
                swap(&processes[i], &processes[j]);
            }
        }
    }
}

void waiting_time(Process processes[], int n, int waiting_times[]) {
    waiting_times[0] = 0;
    for (int i = 1; i < n; i++) {
        waiting_times[i] = processes[i - 1].burst_time + waiting_times[i - 1];
    }
}

void turnaround_time(Process processes[], int n, int waiting_times[], int turnaround_times[]) {
    for (int i = 0; i < n; i++) {
        turnaround_times[i] = processes[i].burst_time + waiting_times[i];
    }
}

void print_table(Process processes[], int n, int waiting_times[], int turnaround_times[]) {
    printf("PID\tPriority\tBurst Time\tWaiting Time\tTurnaround Time\n");
    for (int i = 0; i < n; i++) {
        printf("%d\t%d\t\t%d\t\t%d\t\t%d\n", processes[i].pid, processes[i].priority, processes[i].burst_time, waiting_times[i], turnaround_times[i]);
    }
}

void print_average_time(Process processes[], int n, int waiting_times[], int turnaround_times[]) {
    int total_waiting_time = 0, total_turnaround_time = 0;
    for (int i = 0; i < n; i++) {
        total_waiting_time += waiting_times[i];
        total_turnaround_time += turnaround_times[i];
    }
    printf("Average Waiting Time = %f\n", (float)total_waiting_time / (float)n);
    printf("Average Turnaround Time = %f\n", (float)total_turnaround_time / (float)n);
}

int main() {
    Process processes[MAX_PROCESS] = {
        {1, 3, 10},
        {2, 1, 5},
        {3, 4, 8},
        {4, 2, 12},
        {5, 5, 4}
    };
    int n = MAX_PROCESS;
    int waiting_times[MAX_PROCESS], turnaround_times[MAX_PROCESS];

    sort(processes, n);

    waiting_time(processes, n, waiting_times);

    turnaround_time(processes, n, waiting_times, turnaround_times);

    print_table(processes, n, waiting_times, turnaround_times);

    print_average_time(processes, n, waiting_times, turnaround_times);

    return 0;
}

在这个示例中，我们首先定义了一个包含进程 ID、优先级和 CPU 执行时间的结构体。然后，我们定义了一些帮助函数，包括排序函数、等待时间计算函数和周转时间计算函数。最后，我们在 main 函数中定义了 5 个进程，并使用优先级调度算法对它们进行排序，然后计算等待时间和周转时间，并输出结果。