单道批处理作业调度算法链式队列c

单道批处理作业调度算法可以使用链式队列来实现。具体实现步骤如下：

1. 定义作业控制块（JCB）结构体，包含作业号、到达时间、运行时间、开始时间、完成时间等信息。

2. 定义队列结构体，包含队头指针、队尾指针、队列长度等信息，以及入队和出队操作。

3. 读入所有作业的信息，按照到达时间从小到大排序。

4. 初始化一个空队列，将第一个作业入队。

5. 当队列不为空时，执行以下操作：

1）从队列中取出队头作业。

2）计算该作业的开始时间和完成时间。

3）输出该作业的信息。

4）将下一个到达时间小于该作业完成时间的作业入队。

6. 所有作业都处理完毕后，统计平均周转时间、平均带权周转时间等指标并输出。

下面是使用链式队列实现单道批处理作业调度算法的C语言代码示例：

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

// 定义作业控制块结构体
typedef struct JCB {
    int job_id;         // 作业号
    int arrive_time;    // 到达时间
    int run_time;       // 运行时间
    int start_time;     // 开始时间
    int finish_time;    // 完成时间
    struct JCB *next;   // 指向下一个作业的指针
} JCB;

// 定义队列结构体
typedef struct Queue {
    JCB *front;     // 队头指针
    JCB *rear;      // 队尾指针
    int length;     // 队列长度
} Queue;

// 初始化队列
void initQueue(Queue *q) {
    q->front = q->rear = NULL;
    q->length = 0;
}

// 判断队列是否为空
int isEmpty(Queue *q) {
    return q->length == 0;
}

// 入队
void enQueue(Queue *q, JCB *jcb) {
    if (isEmpty(q)) {
        q->front = q->rear = jcb;
    } else {
        q->rear->next = jcb;
        q->rear = jcb;
    }
    q->length++;
}

// 出队
JCB* deQueue(Queue *q) {
    if (isEmpty(q)) {
        return NULL;
    }
    JCB *jcb = q->front;
    q->front = jcb->next;
    q->length--;
    if (q->length == 0) {
        q->front = q->rear = NULL;
    }
    return jcb;
}

int main() {
    int n;
    printf("请输入作业数：");
    scanf("%d", &n);
    JCB *jcb[n];
    Queue q;
    initQueue(&q);
    // 读入作业信息并按到达时间排序
    for (int i = 0; i < n; i++) {
        jcb[i] = (JCB*)malloc(sizeof(JCB));
        printf("请输入作业%d的到达时间和运行时间：", i+1);
        scanf("%d%d", &jcb[i]->arrive_time, &jcb[i]->run_time);
        jcb[i]->job_id = i + 1;
        jcb[i]->next = NULL;
        // 将作业插入队列中
        enQueue(&q, jcb[i]);
    }
    // 执行作业调度算法
    int current_time = q.front->arrive_time;   // 当前时间
    double total_turnaround_time = 0.0;         // 总周转时间
    double total_weighted_turnaround_time = 0.0;// 总带权周转时间
    while (!isEmpty(&q)) {
        JCB *j = deQueue(&q);   // 取出队头作业
        j->start_time = current_time;   // 计算开始时间
        j->finish_time = j->start_time + j->run_time; // 计算完成时间
        total_turnaround_time += j->finish_time - j->arrive_time;   // 统计周转时间
        total_weighted_turnaround_time += (j->finish_time - j->arrive_time) * 1.0 / j->run_time; // 统计带权周转时间
        printf("作业%d的开始时间：%d，完成时间：%d\n", j->job_id, j->start_time, j->finish_time);
        current_time = j->finish_time;  // 更新当前时间
        // 将下一个到达时间小于该作业完成时间的作业入队
        for (int i = 0; i < n; i++) {
            if (jcb[i]->arrive_time > current_time) {
                break;
            }
            if (jcb[i] != j && jcb[i]->start_time == 0) {
                enQueue(&q, jcb[i]);
            }
        }
    }
    // 输出统计结果
    printf("平均周转时间：%f，平均带权周转时间：%f\n", total_turnaround_time / n, total_weighted_turnaround_time / n);
    return 0;
}

注意，这里只是一种实现方式，还有其他的实现方式，具体可以根据实际情况进行选择。