运用c语言编程实现进程调度算法的基本过程，设计要求： （1）能够选择进程调度算法（先来先服务、短进程优先算法和高响应比优先算法）。 （2）可以输入进程数目（至少3个进程），以及各进程的提交时间和运行时间。 （3）能够显示调度过程及相应时间。(4)输出结果包含周转时间和带权周转时间(5)并有相关注释

以下是一个使用C语言编写的进程调度算法程序，实现了先来先服务、短进程优先算法和高响应比优先算法。

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

// 进程结构体
typedef struct {
    int pid;  // 进程ID
    int at;   // 到达时间
    int bt;   // 运行时间
    int ct;   // 完成时间
    int tat;  // 周转时间
    float wt; // 带权周转时间
} Process;

// 比较函数，用于排序
int cmp(const void *a, const void *b) {
    return ((Process*)a)->at - ((Process*)b)->at;
}

// 选择进程调度算法
int select_algorithm() {
    int alg;
    printf("请选择进程调度算法：\n");
    printf("1. 先来先服务\n");
    printf("2. 短进程优先\n");
    printf("3. 高响应比优先\n");
    printf("请输入数字选择算法：");
    scanf("%d", &alg);
    return alg;
}

// 输入进程数目和信息
void input(Process *p, int n) {
    int i;
    printf("请输入每个进程的到达时间和运行时间：\n");
    for (i = 0; i < n; i++) {
        printf("进程%d：", i + 1);
        scanf("%d %d", &p[i].at, &p[i].bt);
        p[i].pid = i + 1;
    }
}

// 先来先服务（FCFS）算法
void fcfs(Process *p, int n) {
    int i;
    float avg_tat = 0, avg_wt = 0;
    p[0].ct = p[0].at + p[0].bt;
    p[0].tat = p[0].ct - p[0].at;
    p[0].wt = (float)p[0].tat / p[0].bt;
    for (i = 1; i < n; i++) {
        if (p[i].at > p[i - 1].ct) {
            p[i].ct = p[i].at + p[i].bt;
        } else {
            p[i].ct = p[i - 1].ct + p[i].bt;
        }
        p[i].tat = p[i].ct - p[i].at;
        p[i].wt = (float)p[i].tat / p[i].bt;
    }
    printf("进程\t到达时间\t运行时间\t完成时间\t周转时间\t带权周转时间\n");
    for (i = 0; i < n; i++) {
        printf("%d\t%d\t\t%d\t\t%d\t\t%d\t\t%.2f\n", p[i].pid, p[i].at, p[i].bt, p[i].ct, p[i].tat, p[i].wt);
        avg_tat += p[i].tat;
        avg_wt += p[i].wt;
    }
    avg_tat /= n;
    avg_wt /= n;
    printf("平均周转时间：%.2f\n", avg_tat);
    printf("平均带权周转时间：%.2f\n", avg_wt);
}

// 短进程优先（SJF）算法
void sjf(Process *p, int n) {
    int i, j, t = 0;
    float avg_tat = 0, avg_wt = 0;
    qsort(p, n, sizeof(Process), cmp);
    for (i = 0; i < n; i++) {
        t += p[i].bt;
        p[i].ct = t;
        p[i].tat = p[i].ct - p[i].at; 
        p[i].wt = (float)p[i].tat / p[i].bt;
    }
    printf("进程\t到达时间\t运行时间\t完成时间\t周转时间\t带权周转时间\n");
    for (i = 0; i < n; i++) {
        printf("%d\t%d\t\t%d\t\t%d\t\t%d\t\t%.2f\n", p[i].pid, p[i].at, p[i].bt, p[i].ct, p[i].tat, p[i].wt);
        avg_tat += p[i].tat;
        avg_wt += p[i].wt;
    }
    avg_tat /= n;
    avg_wt /= n;
    printf("平均周转时间：%.2f\n", avg_tat);
    printf("平均带权周转时间：%.2f\n", avg_wt);
}

// 高响应比优先（HRRN）算法
void hrrn(Process *p, int n) {
    int i, j, t = 0;
    float avg_tat = 0, avg_wt = 0, max_wt_ratio;
    for (i = 0; i < n; i++) {
        max_wt_ratio = -1;
        for (j = 0; j < n; j++) {
            if (p[j].ct == 0) { // 未完成的进程
                float wt_ratio = 1 + (t - p[j].at) / (float)p[j].bt;
                if (wt_ratio > max_wt_ratio) {
                    max_wt_ratio = wt_ratio;
                    i = j;
                }
            }
        }
        t += p[i].bt;
        p[i].ct = t;
        p[i].tat = p[i].ct - p[i].at; 
        p[i].wt = (float)p[i].tat / p[i].bt;
    }
    printf("进程\t到达时间\t运行时间\t完成时间\t周转时间\t带权周转时间\n");
    for (i = 0; i < n; i++) {
        printf("%d\t%d\t\t%d\t\t%d\t\t%d\t\t%.2f\n", p[i].pid, p[i].at, p[i].bt, p[i].ct, p[i].tat, p[i].wt);
        avg_tat += p[i].tat;
        avg_wt += p[i].wt;
    }
    avg_tat /= n;
    avg_wt /= n;
    printf("平均周转时间：%.2f\n", avg_tat);
    printf("平均带权周转时间：%.2f\n", avg_wt);
}

int main() {
    int n, alg;
    printf("请输入进程数目：");
    scanf("%d", &n);
    Process p[n];
    input(p, n);
    alg = select_algorithm();
    switch (alg) {
        case 1:
            fcfs(p, n);
            break;
        case 2:
            sjf(p, n);
            break;
        case 3:
            hrrn(p, n);
            break;
        default:
            printf("输入错误！\n");
    }
    return 0;
}

程序中使用了结构体来存储每个进程的信息，包括进程ID、到达时间、运行时间、完成时间、周转时间和带权周转时间。使用了qsort库函数来对进程按照到达时间排序。选择算法和输入进程数目和信息都是通过用户输入实现的。在每个算法的函数中，都使用了不同的逻辑来计算每个进程的完成时间、周转时间和带权周转时间，并输出结果。

注释中已经详细解释了每个函数和变量的作用，如果还有问题可以提出来。