请你用C语言写出一个优先级调度算法，包括平均周转时间和平均带权周转时间的计算，输入要有进程到达时间和服务时间

好的，以下是一个简单的优先级调度算法的C语言实现，包括计算平均周转时间和平均带权周转时间的函数：

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

#define MAX_PROCESSES 20

// 进程控制块
typedef struct {
    int pid; // 进程ID
    int arrival_time; // 到达时间
    int service_time; // 服务时间
    int priority; // 优先级
    int start_time; // 开始时间
    int completion_time; // 完成时间
} process_t;

// 计算平均周转时间和平均带权周转时间
void calculate_average_times(process_t processes[], int n, float *avg_tat, float *avg_wt) {
    int i;

    // 初始化平均周转时间和平均带权周转时间
    *avg_tat = 0;
    *avg_wt = 0;

    // 计算每个进程的周转时间和带权周转时间
    for (i = 0; i < n; i++) {
        processes[i].completion_time = processes[i].start_time + processes[i].service_time;
        *avg_tat += processes[i].completion_time - processes[i].arrival_time;
        *avg_wt += (processes[i].completion_time - processes[i].arrival_time) / (float) processes[i].service_time;
    }

    // 计算平均周转时间和平均带权周转时间
    *avg_tat /= n;
    *avg_wt /= n;
}

// 优先级调度算法
void priority_scheduling(process_t processes[], int n) {
    int i, j, time = 0;
    process_t temp;

    // 按到达时间排序
    for (i = 0; i < n - 1; i++) {
        for (j = i + 1; j < n; j++) {
            if (processes[i].arrival_time > processes[j].arrival_time) {
                temp = processes[i];
                processes[i] = processes[j];
                processes[j] = temp;
            }
        }
    }

    // 按优先级调度
    for (i = 0; i < n; i++) {
        // 找到优先级最高的进程
        int highest_priority = -1, index = -1;
        for (j = 0; j < n; j++) {
            if (processes[j].arrival_time <= time && processes[j].priority > highest_priority) {
                highest_priority = processes[j].priority;
                index = j;
            }
        }

        if (index == -1) { // 没有进程可调度
            time++;
            i--;
            continue;
        }

        // 调度进程
        processes[index].start_time = time;
        time += processes[index].service_time;
    }
}

int main() {
    process_t processes[MAX_PROCESSES];
    int n, i;
    float avg_tat, avg_wt;

    // 输入进程信息
    printf("Enter the number of processes: ");
    scanf("%d", &n);
    for (i = 0; i < n; i++) {
        printf("Enter the arrival time, service time, and priority of process %d: ", i + 1);
        scanf("%d %d %d", &processes[i].arrival_time, &processes[i].service_time, &processes[i].priority);
        processes[i].pid = i + 1;
    }

    // 运行优先级调度算法
    priority_scheduling(processes, n);

    // 输出进程执行顺序和各个进程的周转时间和带权周转时间
    printf("Process execution order: ");
    for (i = 0; i < n; i++) {
        printf("P%d ", processes[i].pid);
    }
    printf("\n");
    calculate_average_times(processes, n, &avg_tat, &avg_wt);
    printf("Average turnaround time: %.2f\n", avg_tat);
    printf("Average weighted turnaround time: %.2f\n", avg_wt);

    return 0;
}

这个程序中，`process_t`是一个进程控制块的结构体，包含了进程的各种信息，如进程ID、到达时间、服务时间、优先级、开始时间和完成时间等。

`priority_scheduling`函数是优先级调度算法的主体部分，它首先按到达时间排序，然后按优先级调度进程。在每个时间片内，它会找到优先级最高的进程并调度它。如果没有进程可调度，则时间加1，继续循环。

`calculate_average_times`函数用来计算平均周转时间和平均带权周转时间，它遍历每个进程，计算它们的周转时间和带权周转时间，并累加到`avg_tat`和`avg_wt`中。最后除以总进程数，得到平均值。

在`main`函数中，我们先输入进程信息，然后运行优先级调度算法，并输出进程执行顺序以及各个进程的平均周转时间和平均带权周转时间。