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

以下是基于C语言实现进程调度算法的基本过程：

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

//定义进程结构体
typedef struct process {
    int pid;  //进程ID
    int submit_time;  //提交时间
    int run_time;  //运行时间
    int wait_time;  //等待时间
    int turn_time;  //周转时间
    float wturn_time;  //带权周转时间
} Process;

//先来先服务算法
void FCFS(Process *p, int n) {
    int i, j;
    int current_time = 0;  //当前时间
    for (i = 0; i < n; i++) {
        if (current_time < p[i].submit_time) {
            current_time = p[i].submit_time;
        }
        p[i].wait_time = current_time - p[i].submit_time;
        p[i].turn_time = p[i].wait_time + p[i].run_time;
        p[i].wturn_time = (float)p[i].turn_time / (float)p[i].run_time;
        current_time += p[i].run_time;
    }
}

//短进程优先算法
void SJF(Process *p, int n) {
    int i, j;
    int current_time = 0;  //当前时间
    Process temp;
    for (i = 0; i < n; i++) {
        for (j = i + 1; j < n; j++) {
            if (p[i].run_time > p[j].run_time) {
                temp = p[i];
                p[i] = p[j];
                p[j] = temp;
            }
        }
    }
    for (i = 0; i < n; i++) {
        if (current_time < p[i].submit_time) {
            current_time = p[i].submit_time;
        }
        p[i].wait_time = current_time - p[i].submit_time;
        p[i].turn_time = p[i].wait_time + p[i].run_time;
        p[i].wturn_time = (float)p[i].turn_time / (float)p[i].run_time;
        current_time += p[i].run_time;
    }
}

//高响应比优先算法
void HRRN(Process *p, int n) {
    int i, j;
    int current_time = 0;
    float max_rr;
    Process temp;
    for (i = 0; i < n; i++) {
        if (current_time < p[i].submit_time) {
            current_time = p[i].submit_time;
        }
        max_rr = -1;
        for (j = i; j < n; j++) {
            if (p[j].submit_time <= current_time) {
                float rr = (float)(p[j].wait_time + p[j].run_time) / (float)p[j].run_time;
                if (rr > max_rr) {
                    max_rr = rr;
                    temp = p[j];
                    p[j] = p[i];
                    p[i] = temp;
                }
            }
        }
        p[i].wait_time = current_time - p[i].submit_time;
        p[i].turn_time = p[i].wait_time + p[i].run_time;
        p[i].wturn_time = (float)p[i].turn_time / (float)p[i].run_time;
        current_time += p[i].run_time;
    }
}

int main() {
    int i, n, choice;
    printf("请输入进程数目：");
    scanf("%d", &n);
    Process *p = (Process *)malloc(n * sizeof(Process));
    printf("请分别输入每个进程的提交时间和运行时间：\n");
    for (i = 0; i < n; i++) {
        printf("进程%d：", i + 1);
        scanf("%d %d", &p[i].submit_time, &p[i].run_time);
        p[i].pid = i + 1;
    }
    printf("请选择进程调度算法：\n");
    printf("1.先来先服务算法\n");
    printf("2.短进程优先算法\n");
    printf("3.高响应比优先算法\n");
    scanf("%d", &choice);
    switch (choice) {
        case 1:
            FCFS(p, n);
            break;
        case 2:
            SJF(p, n);
            break;
        case 3:
            HRRN(p, n);
            break;
        default:
            printf("输入错误！\n");
            break;
    }
    printf("进程ID\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].submit_time, p[i].run_time, p[i].wait_time, p[i].turn_time, p[i].wturn_time);
    }
    free(p);
    return 0;
}

程序中定义了一个进程结构体，包含进程的基本信息，如进程ID、提交时间、运行时间、等待时间、周转时间和带权周转时间。然后定义了三个进程调度算法的函数，分别是先来先服务算法、短进程优先算法和高响应比优先算法。在主函数中，首先输入进程数目和每个进程的提交时间和运行时间，然后选择进程调度算法，根据选择调用相应的算法函数，最后输出每个进程的信息，包括进程ID、提交时间、运行时间、等待时间、周转时间和带权周转时间。

需要注意的是，这里使用了动态内存分配，即使用malloc函数在堆上分配了一段内存来存储进程信息，最后使用free函数释放了这段内存，避免了内存泄漏问题。此外，程序中还添加了一些注释，方便理解和修改。