要求输入3个进程的信息，按照最高响应比优先的调度算法计算并输出每个进程的周转时间。(若两个进程的响应比相同，则优先选择先进入的进程。若两个进程的响应比相同，而且进入时刻也相同，则按照输入的顺序执行，如：P4和P6的响应比相同且进入时刻也相同，如P4先输入则选择P4先执行)用C语言

### 回答1：
以下是使用C语言实现的最高响应比优先调度算法：

#include <stdio.h>

#define MAX_PROCESS 10 // 进程数的最大值

struct process {
    int id; // 进程ID
    int arrival_time; // 到达时间
    int burst_time; // 执行时间
    int waiting_time; // 等待时间
    int turnaround_time; // 周转时间
    double priority; // 响应比
};

int main() {
    int n; // 进程数
    struct process processes[MAX_PROCESS]; // 进程数组
    int i, j, k;
    struct process temp;
    int time = 0; // 当前时间
    int complete = 0; // 完成的进程数
    double max_priority; // 最高响应比
    int max_priority_process; // 具有最高响应比的进程的下标

    // 输入进程信息
    printf("请输入进程数：");
    scanf("%d", &n);
    printf("请依次输入每个进程的到达时间和执行时间：\n");
    for (i = 0; i < n; i++) {
        processes[i].id = i + 1;
        scanf("%d%d", &processes[i].arrival_time, &processes[i].burst_time);
        processes[i].waiting_time = 0;
        processes[i].turnaround_time = 0;
        processes[i].priority = 0;
    }

    // 计算响应比
    for (i = 0; i < n; i++) {
        processes[i].priority = 1 + (double) (time - processes[i].arrival_time) / processes[i].burst_time;
    }

    // 按照响应比排序
    for (i = 0; i < n - 1; i++) {
        k = i;
        for (j = i + 1; j < n; j++) {
            if (processes[j].priority > processes[k].priority) {
                k = j;
            }
            else if (processes[j].priority == processes[k].priority && processes[j].arrival_time < processes[k].arrival_time) {
                k = j;
            }
        }
        temp = processes[k];
        processes[k] = processes[i];
        processes[i] = temp;
    }

    // 执行进程
    printf("\n进程调度顺序：\n");
    printf("进程\t到达时间\t执行时间\t等待时间\t周转时间\n");
    while (complete < n) {
        max_priority = 0;
        max_priority_process = -1;
        for (i = 0; i < n; i++) {
            if (processes[i].arrival_time <= time && processes[i].priority >= max_priority) {
                max_priority = processes[i].priority;
                max_priority_process = i;
            }
        }
        if (max_priority_process == -1) {
            time++;
            continue;
        }
        processes[max_priority_process].waiting_time = time - processes[max_priority_process].arrival_time;
        processes[max_priority_process].turnaround_time = processes[max_priority_process].waiting_time + processes[max_priority_process].burst_time;
        time += processes[max_priority_process].burst_time;
        complete++;
        printf("P%d\t%d\t\t%d\t\t%d\t\t%d\n", processes[max_priority_process].id, processes[max_priority_process].arrival_time, processes[max_priority_process].burst_time, processes[max_priority_process].waiting_time, processes[max_priority_process].turnaround_time);
    }

    // 计算平均等待时间和平均周转时间
    double average_waiting_time = 0;
    double average_turnaround_time = 0;
    for (i = 0; i < n; i++) {
        average_waiting_time += processes[i].waiting_time;
        average_turnaround_time += processes[i].turnaround_time;
    }
    average_waiting_time /= n;
    average_turnaround_time /= n;
    printf("\n平均等待时间：%.2f\n", average_waiting_time);
    printf("平均周转时间：%.2f\n", average_turnaround_time);

    return 0;
}

需要注意的是，此算法中的响应比定义为：$\frac{1+(当前时间-到达时间)}{执行时间}$。

### 回答2：
下面是一个用C语言实现最高响应比优先调度算法的例子：

#include<stdio.h>

// 进程结构体
typedef struct{
    int pid;  // 进程编号
    int arrivalTime;  // 到达时间
    int burstTime;  // 服务时间
    int waitingTime;  // 等待时间
    float responseRatio;  // 响应比
    int turnaroundTime;  // 周转时间
}Process;

// 计算响应比
float calculateResponseRatio(Process p, int currentTime){
    return 1 + (float)p.waitingTime / p.burstTime;
}

// 找到最高响应比进程的索引
int findHighestResponseRatio(Process *processes, int n, int currentTime){
    int highestIndex = -1;
    float highestRatio = -1;
    for(int i=0; i<n; i++){
        if(processes[i].arrivalTime <= currentTime && processes[i].turnaroundTime == -1){
            float ratio = calculateResponseRatio(processes[i], currentTime);
            if(ratio > highestRatio){
                highestRatio = ratio;
                highestIndex = i;
            }
        }
    }
    return highestIndex;
}

// 计算等待时间和周转时间
void calculateWaitingAndTurnaroundTime(Process *processes, int n){
    int currentTime = 0;
    int completed = 0;
    
    while(completed < n){
        int index = findHighestResponseRatio(processes, n, currentTime);
        if(index == -1){  // 当前时刻无进程可执行
            currentTime++;
            continue;
        }
        
        Process *p = &processes[index];
        p->waitingTime = currentTime - p->arrivalTime;
        p->turnaroundTime = p->waitingTime + p->burstTime;
        currentTime += p->burstTime;
        completed++;
    }
}

int main(){
    int n = 3;  // 进程数量
    Process processes[n];
    
    // 输入进程信息
    for(int i=0; i<n; i++){
        printf("请输入进程 %d 的到达时间：", i+1);
        scanf("%d", &processes[i].arrivalTime);
        printf("请输入进程 %d 的服务时间：", i+1);
        scanf("%d", &processes[i].burstTime);
        processes[i].pid = i+1;
        processes[i].waitingTime = -1;
        processes[i].turnaroundTime = -1;
    }
    
    calculateWaitingAndTurnaroundTime(processes, n);
    
    // 输出每个进程的周转时间
    printf("进程\t到达时间\t服务时间\t等待时间\t周转时间\n");
    for(int i=0; i<n; i++){
        printf("P%d\t%d\t\t%d\t\t%d\t\t%d\n", 
            processes[i].pid, processes[i].arrivalTime, processes[i].burstTime, 
            processes[i].waitingTime, processes[i].turnaroundTime);
    }
    
    return 0;
}

这个程序会首先要求输入每个进程的到达时间和服务时间，然后按照最高响应比优先调度算法计算出每个进程的等待时间和周转时间。最后会输出每个进程的进程编号、到达时间、服务时间、等待时间和周转时间。

### 回答3：
以下是使用C语言编写的按照最高响应比优先调度算法计算并输出每个进程的周转时间的示例代码：

#include <stdio.h>

typedef struct {
    int process_id;
    float burst_time;
    float arrival_time;
    float waiting_time;
    float turnaround_time;
    float response_ratio;
} Process;

void calculate_waiting_time(Process processes[], int n) {
    float total_waiting_time = 0;
    float total_turnaround_time = 0;

    for (int i = 0; i < n; i++) {
        int min_response_ratio_index = i;
        for (int j = i + 1; j < n; j++) {
            if (processes[j].response_ratio > processes[min_response_ratio_index].response_ratio) {
                min_response_ratio_index = j;
            }
            else if (processes[j].response_ratio == processes[min_response_ratio_index].response_ratio && processes[j].arrival_time < processes[min_response_ratio_index].arrival_time) {
                min_response_ratio_index = j;
            }
        }

        // Swap the processes
        Process temp = processes[min_response_ratio_index];
        processes[min_response_ratio_index] = processes[i];
        processes[i] = temp;

        // Calculate waiting time
        if (i == 0) {
            processes[i].waiting_time = 0;
            processes[i].turnaround_time = processes[i].burst_time;
        }
        else {
            processes[i].waiting_time = processes[i - 1].turnaround_time - processes[i].arrival_time;
            if (processes[i].waiting_time < 0) {
                processes[i].waiting_time = 0;
            }
            processes[i].turnaround_time = processes[i].waiting_time + processes[i].burst_time;
        }

        total_waiting_time += processes[i].waiting_time;
        total_turnaround_time += processes[i].turnaround_time;
    }

    // Print the result
    printf("进程\t周转时间\n");
    for (int i = 0; i < n; i++) {
        printf("P%d\t%.2f\n", processes[i].process_id, processes[i].turnaround_time);
    }

    // Calculate average waiting time
    float average_waiting_time = total_waiting_time / n;
    printf("平均等待时间: %.2f\n", average_waiting_time);

    // Calculate average turnaround time
    float average_turnaround_time = total_turnaround_time / n;
    printf("平均周转时间: %.2f\n", average_turnaround_time);
}

int main() {
    int n;
    printf("请输入进程数量：");
    scanf("%d", &n);

    Process processes[n];

    for (int i = 0; i < n; i++) {
        printf("请输入进程ID、到达时间和执行时间（以空格分隔）：");
        scanf("%d %f %f", &processes[i].process_id, &processes[i].arrival_time, &processes[i].burst_time);

        processes[i].response_ratio = (processes[i].burst_time + processes[i].arrival_time) / processes[i].burst_time;
    }

    calculate_waiting_time(processes, n);

    return 0;
}

你可以通过输入进程的数量以及每个进程的ID、到达时间和执行时间来计算每个进程的周转时间。代码将会按照最高响应比优先的调度算法进行排序，并输出每个进程的周转时间，以及平均等待时间和平均周转时间。