单道处理系统的作业等待模拟程序。 作业等待算法：分别采用先来先服务（FCFS），最短作业优先（SJF）、响应比高者优先（HRN）的调度算法。 对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间，以及这组作业的平均周转时间及带权平均周转时间，以比较各种算法的优缺点。使用c语言

以下是使用C语言实现的单道处理系统的作业等待模拟程序，包括三种调度算法：先来先服务（FCFS）、最短作业优先（SJF）、响应比高者优先（HRN）：

#include<stdio.h>

#define MAX_SIZE 100

// 作业结构体
typedef struct Job {
    int id;             // 作业编号
    int arrivalTime;    // 到达时间
    int runTime;        // 运行时间
    int startTime;      // 开始时间
    int finishTime;     // 完成时间
    int turnaroundTime; // 周转时间
    float weightTurnaroundTime; // 带权周转时间
} Job;

// 作业队列结构体
typedef struct JobQueue {
    int size;           // 队列大小
    Job jobs[MAX_SIZE]; // 作业数组
} JobQueue;

// 初始化作业队列
void initJobQueue(JobQueue *queue) {
    queue->size = 0;
}

// 添加作业到队列
void addJob(JobQueue *queue, Job job) {
    queue->jobs[queue->size++] = job;
}

// 按到达时间排序
void sortByArrivalTime(JobQueue *queue) {
    int i, j;
    Job temp;
    for(i = 0; i < queue->size - 1; i++) {
        for(j = i + 1; j < queue->size; j++) {
            if(queue->jobs[i].arrivalTime > queue->jobs[j].arrivalTime) {
                temp = queue->jobs[i];
                queue->jobs[i] = queue->jobs[j];
                queue->jobs[j] = temp;
            }
        }
    }
}

// FCFS算法
void fcfs(JobQueue *queue) {
    int i, currentTime = 0;
    float avgTurnaroundTime = 0, avgWeightTurnaroundTime = 0;

    printf("FCFS调度算法：\n");

    // 按到达时间排序
    sortByArrivalTime(queue);

    // 遍历队列，计算开始时间、完成时间、周转时间、带权周转时间
    for(i = 0; i < queue->size; i++) {
        if(currentTime < queue->jobs[i].arrivalTime) {
            currentTime = queue->jobs[i].arrivalTime;
        }
        queue->jobs[i].startTime = currentTime;
        queue->jobs[i].finishTime = currentTime + queue->jobs[i].runTime;
        queue->jobs[i].turnaroundTime = queue->jobs[i].finishTime - queue->jobs[i].arrivalTime;
        queue->jobs[i].weightTurnaroundTime = (float)queue->jobs[i].turnaroundTime / queue->jobs[i].runTime;

        currentTime = queue->jobs[i].finishTime;

        // 打印作业信息
        printf("作业%d：开始时间：%d，完成时间：%d，周转时间：%d，带权周转时间：%f\n", 
            queue->jobs[i].id, queue->jobs[i].startTime, queue->jobs[i].finishTime, 
            queue->jobs[i].turnaroundTime, queue->jobs[i].weightTurnaroundTime);

        // 累加周转时间、带权周转时间
        avgTurnaroundTime += queue->jobs[i].turnaroundTime;
        avgWeightTurnaroundTime += queue->jobs[i].weightTurnaroundTime;
    }

    // 计算平均周转时间、带权平均周转时间
    avgTurnaroundTime /= queue->size;
    avgWeightTurnaroundTime /= queue->size;

    printf("平均周转时间：%f，带权平均周转时间：%f\n", avgTurnaroundTime, avgWeightTurnaroundTime);
}

// SJF算法
void sjf(JobQueue *queue) {
    int i, j, currentTime = 0, minIndex;
    float avgTurnaroundTime = 0, avgWeightTurnaroundTime = 0;

    printf("SJF调度算法：\n");

    // 按到达时间排序
    sortByArrivalTime(queue);

    // 遍历队列，计算开始时间、完成时间、周转时间、带权周转时间
    for(i = 0; i < queue->size; i++) {
        minIndex = i;
        for(j = i + 1; j < queue->size; j++) {
            if(queue->jobs[j].runTime < queue->jobs[minIndex].runTime) {
                minIndex = j;
            }
        }
        if(currentTime < queue->jobs[minIndex].arrivalTime) {
            currentTime = queue->jobs[minIndex].arrivalTime;
        }
        queue->jobs[minIndex].startTime = currentTime;
        queue->jobs[minIndex].finishTime = currentTime + queue->jobs[minIndex].runTime;
        queue->jobs[minIndex].turnaroundTime = queue->jobs[minIndex].finishTime - queue->jobs[minIndex].arrivalTime;
        queue->jobs[minIndex].weightTurnaroundTime = (float)queue->jobs[minIndex].turnaroundTime / queue->jobs[minIndex].runTime;

        currentTime = queue->jobs[minIndex].finishTime;

        // 打印作业信息
        printf("作业%d：开始时间：%d，完成时间：%d，周转时间：%d，带权周转时间：%f\n", 
            queue->jobs[minIndex].id, queue->jobs[minIndex].startTime, queue->jobs[minIndex].finishTime, 
            queue->jobs[minIndex].turnaroundTime, queue->jobs[minIndex].weightTurnaroundTime);

        // 累加周转时间、带权周转时间
        avgTurnaroundTime += queue->jobs[minIndex].turnaroundTime;
        avgWeightTurnaroundTime += queue->jobs[minIndex].weightTurnaroundTime;

        // 将已经处理的作业从队列中删除
        queue->jobs[minIndex] = queue->jobs[i];
    }

    // 计算平均周转时间、带权平均周转时间
    avgTurnaroundTime /= queue->size;
    avgWeightTurnaroundTime /= queue->size;

    printf("平均周转时间：%f，带权平均周转时间：%f\n", avgTurnaroundTime, avgWeightTurnaroundTime);
}

// HRN算法
void hrn(JobQueue *queue) {
    int i, j, currentTime = 0, maxIndex;
    float avgTurnaroundTime = 0, avgWeightTurnaroundTime = 0;

    printf("HRN调度算法：\n");

    // 按到达时间排序
    sortByArrivalTime(queue);

    // 遍历队列，计算开始时间、完成时间、周转时间、带权周转时间
    for(i = 0; i < queue->size; i++) {
        maxIndex = i;
        for(j = i + 1; j < queue->size; j++) {
            float ratio1 = (float)(currentTime - queue->jobs[j].arrivalTime + queue->jobs[j].runTime) / queue->jobs[j].runTime;
            float ratio2 = (float)(currentTime - queue->jobs[maxIndex].arrivalTime + queue->jobs[maxIndex].runTime) / queue->jobs[maxIndex].runTime;
            if(ratio1 > ratio2) {
                maxIndex = j;
            }
        }
        if(currentTime < queue->jobs[maxIndex].arrivalTime) {
            currentTime = queue->jobs[maxIndex].arrivalTime;
        }
        queue->jobs[maxIndex].startTime = currentTime;
        queue->jobs[maxIndex].finishTime = currentTime + queue->jobs[maxIndex].runTime;
        queue->jobs[maxIndex].turnaroundTime = queue->jobs[maxIndex].finishTime - queue->jobs[maxIndex].arrivalTime;
        queue->jobs[maxIndex].weightTurnaroundTime = (float)queue->jobs[maxIndex].turnaroundTime / queue->jobs[maxIndex].runTime;

        currentTime = queue->jobs[maxIndex].finishTime;

        // 打印作业信息
        printf("作业%d：开始时间：%d，完成时间：%d，周转时间：%d，带权周转时间：%f\n", 
            queue->jobs[maxIndex].id, queue->jobs[maxIndex].startTime, queue->jobs[maxIndex].finishTime, 
            queue->jobs[maxIndex].turnaroundTime, queue->jobs[maxIndex].weightTurnaroundTime);

        // 累加周转时间、带权周转时间
        avgTurnaroundTime += queue->jobs[maxIndex].turnaroundTime;
        avgWeightTurnaroundTime += queue->jobs[maxIndex].weightTurnaroundTime;

        // 将已经处理的作业从队列中删除
        queue->jobs[maxIndex] = queue->jobs[i];
    }

    // 计算平均周转时间、带权平均周转时间
    avgTurnaroundTime /= queue->size;
    avgWeightTurnaroundTime /= queue->size;

    printf("平均周转时间：%f，带权平均周转时间：%f\n", avgTurnaroundTime, avgWeightTurnaroundTime);
}

int main() {
    JobQueue queue;
    initJobQueue(&queue);

    // 添加作业到队列
    addJob(&queue, (Job){1, 0, 3});
    addJob(&queue, (Job){2, 2, 6});
    addJob(&queue, (Job){3, 4, 4});
    addJob(&queue, (Job){4, 6, 2});
    addJob(&queue, (Job){5, 8, 5});

    // 执行FCFS算法
    fcfs(&queue);

    // 执行SJF算法
    sjf(&queue);

    // 执行HRN算法
    hrn(&queue);

    return 0;
}

程序中使用了作业结构体和作业队列结构体来存储作业信息，实现了初始化作业队列、添加作业到队列、按到达时间排序等功能。

三种调度算法中，FCFS算法是按照作业到达的先后顺序进行调度，SJF算法是按照作业运行时间的长短进行调度，HRN算法是按照响应比高低进行调度。

程序中使用了三个函数来分别实现三种调度算法，遍历作业队列，计算开始时间、完成时间、周转时间、带权周转时间，并打印作业信息。最后计算平均周转时间、带权平均周转时间，并打印出来。

在主函数中，首先初始化作业队列，然后添加作业到队列中。最后依次执行FCFS算法、SJF算法、HRN算法，比较三种算法的优缺点。