用C语言编写程序，编写并调试一个模拟的进程调度程序，采用 “短进程优先”调度算法对多个进程进行调度。 计算平均周转时间和平均带权周转时间。

好的，下面是一个简单的用C语言编写的模拟进程调度程序，采用短进程优先调度算法：

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

#define MAX_PROCESS 10

struct Process {
    int pid;              // 进程ID
    int arrival_time;     // 到达时间
    int burst_time;       // 运行时间
    int waiting_time;     // 等待时间
    int turnaround_time;  // 周转时间
    float weight_turnaround_time;  // 带权周转时间
};

void calculate_wait_time(struct Process *processes, int n) {
    int i, j;
    int total_wait_time = 0;

    // 初始化等待时间为0
    for (i = 0; i < n; i++) {
        processes[i].waiting_time = 0;
    }

    for (i = 0; i < n; i++) {
        for (j = 0; j < i; j++) {
            processes[i].waiting_time += processes[j].burst_time;
        }
        total_wait_time += processes[i].waiting_time;
    }

    printf("\nAverage Waiting Time: %.2f\n", (float)total_wait_time / n);
}

void calculate_turnaround_time(struct Process *processes, int n) {
    int i;
    int total_turnaround_time = 0;

    for (i = 0; i < n; i++) {
        processes[i].turnaround_time = processes[i].burst_time + processes[i].waiting_time;
        total_turnaround_time += processes[i].turnaround_time;
    }

    printf("\nAverage Turnaround Time: %.2f\n", (float)total_turnaround_time / n);
}

void calculate_weight_turnaround_time(struct Process *processes, int n) {
    int i;
    float total_weight_turnaround_time = 0;

    for (i = 0; i < n; i++) {
        processes[i].weight_turnaround_time = (float)processes[i].turnaround_time / processes[i].burst_time;
        total_weight_turnaround_time += processes[i].weight_turnaround_time;
    }

    printf("\nAverage Weighted Turnaround Time: %.2f\n", total_weight_turnaround_time / n);
}

int compare_arrival_time(const void *a, const void *b) {
    const struct Process *p1 = (const struct Process *)a;
    const struct Process *p2 = (const struct Process *)b;

    if (p1->arrival_time < p2->arrival_time) {
        return -1;
    } else if (p1->arrival_time > p2->arrival_time) {
        return 1;
    } else {
        return 0;
    }
}

int compare_burst_time(const void *a, const void *b) {
    const struct Process *p1 = (const struct Process *)a;
    const struct Process *p2 = (const struct Process *)b;

    if (p1->burst_time < p2->burst_time) {
        return -1;
    } else if (p1->burst_time > p2->burst_time) {
        return 1;
    } else {
        return 0;
    }
}

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

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

    for (i = 0; i < n; i++) {
        printf("\nEnter details for process %d:\n", i + 1);
        processes[i].pid = i + 1;

        printf("Arrival Time: ");
        scanf("%d", &processes[i].arrival_time);

        printf("Burst Time: ");
        scanf("%d", &processes[i].burst_time);
    }

    // 按照到达时间排序
    qsort(processes, n, sizeof(struct Process), compare_arrival_time);

    // 短进程优先调度算法
    int current_time = 0;
    int remaining_processes = n;

    while (remaining_processes > 0) {
        // 找到最短的进程
        int shortest_process_index = -1;
        int shortest_burst_time = 9999;

        for (i = 0; i < n; i++) {
            if (processes[i].arrival_time <= current_time && processes[i].burst_time < shortest_burst_time) {
                shortest_process_index = i;
                shortest_burst_time = processes[i].burst_time;
            }
        }

        // 如果没有找到可运行的进程，增加时间片
        if (shortest_process_index == -1) {
            current_time++;
            continue;
        }

        // 运行最短的进程
        struct Process *process = &processes[shortest_process_index];
        process->waiting_time = current_time - process->arrival_time;
        process->turnaround_time = process->waiting_time + process->burst_time;
        process->weight_turnaround_time = (float)process->turnaround_time / process->burst_time;

        current_time += process->burst_time;
        remaining_processes--;

        // 将已经运行过的进程从进程列表中删除
        for (i = shortest_process_index; i < remaining_processes; i++) {
            processes[i] = processes[i + 1];
        }
    }

    calculate_wait_time(processes, n);
    calculate_turnaround_time(processes, n);
    calculate_weight_turnaround_time(processes, n);

    return 0;
}

该程序首先会要求用户输入进程的到达时间和运行时间，然后按照到达时间进行排序，并且按照短进程优先调度算法进行调度，最后输出平均等待时间、平均周转时间和平均带权周转时间。

注意，该程序假设所有进程都能在一个时间片内完成，如果需要考虑时间片长度，则需要对程序进行修改。

希望这个程序能够帮到你，任何问题都可以随时问我！