试验任务：

编写和调试一个进程调度程序，实现基于优先权的进程调度算法或者基于时间片轮转调度算法。编写和调试一个进程调度程序，实现基于优先权的进程调度算法或者基于时间片轮转调度算法。

实验要求

1. 测试数据可以随机输入或从文件中读入。

2. 必须要考虑到进程的到达时间

3. 最终能够计算每一个进程的周转时间

使用语言：c语言

打开文件名为定义为“data.txt”可根据需求进行更改。

废话不多说，以下是源代码：

// 基于优先权的进程调度算法
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

// 定义进程结构体
typedef struct process {
    int id; // 进程标识数
    int priority; // 进程优先数
    int arrival; // 进程到达时间
    int service; // 进程服务时间
    int remain; // 进程剩余时间
    int start; // 进程开始时间
    int finish; // 进程完成时间
    int turnaround; // 进程周转时间
    struct process *next; // 指向下一个进程的指针
} process;

// 定义就绪队列的头尾指针
process *head = NULL;
process *tail = NULL;

// 定义进程个数和时间片长度
int n;
int q;

// 生成随机数的函数，用于生成测试数据
int random(int min, int max) {
    return rand() % (max - min + 1) + min;
}

// 创建进程的函数，用于生成测试数据或从文件中读入数据
void create_process() {
    printf("请输入进程个数：\n");
    scanf("%d", &n);
    printf("请输入时间片长度：\n");
    scanf("%d", &q);
    printf("请选择数据输入方式：\n");
    printf("1. 随机生成\n");
    printf("2. 从文件读入\n");
    int choice;
    scanf("%d", &choice);
    if (choice == 1) {
        // 随机生成数据
        srand(time(NULL)); // 设置随机数种子
        for (int i = 0; i < n; i++) {
            process *p = (process *)malloc(sizeof(process)); // 分配内存空间
            p->id = i + 1; // 设置进程标识数
            p->priority = random(1, 10); // 设置进程优先数，范围为1到10
            p->arrival = random(0, 10); // 设置进程到达时间，范围为0到10
            p->service = random(1, 10); // 设置进程服务时间，范围为1到10
            p->remain = p->service; // 设置进程剩余时间，初始等于服务时间
            p->start = -1; // 设置进程开始时间，初始为-1表示未开始
            p->finish = -1; // 设置进程完成时间，初始为-1表示未完成
            p->turnaround = -1; // 设置进程周转时间，初始为-1表示未计算
            p->next = NULL; // 设置下一个进程指针为空

            if (head == NULL) {
                // 如果就绪队列为空，将新创建的进程作为队头和队尾
                head = p;
                tail = p;
            } else {
                // 如果就绪队列不为空，将新创建的进程插入到队尾，并更新队尾指针
                tail->next = p;
                tail = p;
            }
        }
    } else if (choice == 2) {
        // 从文件读入数据
        FILE *fp = fopen("data.txt", "r"); // 打开文件，只读模式
        if (fp == NULL) {
            printf("打开文件失败！\n");
            exit(1);
        }
        for (int i = 0; i < n; i++) {
            process *p = (process *)malloc(sizeof(process)); // 分配内存空间
            fscanf(fp, "%d %d %d %d", &p->id, &p->priority, &p->arrival, &p->service); // 从文件中读取数据，格式为id priority arrival service
            p->remain = p->service; // 设置进程剩余时间，初始等于服务时间
            p->start = -1; // 设置进程开始时间，初始为-1表示未开始
            p->finish = -1; // 设置进程完成时间，初始为-1表示未完成
            p->turnaround = -1; // 设置进程周转时间，初始为-1表示未计算
            p->next = NULL; // 设置下一个进程指针为空

            if (head == NULL) {
                // 如果就绪队列为空，将新创建的进程作为队头和队尾
                head = p;
                tail = p;
            } else {
                // 如果就绪队列不为空，将新创建的进程插入到队尾，并更新队尾指针
                tail->next = p;
                tail = p;
            }
        }
        fclose(fp); // 关闭文件
    } else {
        printf("无效的输入！\n");
        exit(1);
    }
}

// 按照到达时间对就绪队列进行排序的函数（冒泡排序）
void sort_by_arrival() {
    process *p, *q;
    for (p = head; p != NULL; p = p->next) {
        for (q = head; q != tail; q = q->next) {
            if (q->arrival > q->next->arrival) {
                // 交换两个相邻节点的数据域（不交换指针域）
                int temp_id = q->id;
                int temp_priority = q->priority;
                int temp_arrival = q->arrival;
                int temp_service = q->service;
                int temp_remain = q->remain;
                int temp_start = q->start;
                int temp_finish = q->finish;
                int temp_turnaround = q->turnaround;

                q->id = q->next->id;
                q->priority = q->next->priority;
                q->arrival = q->next->arrival;
                q->service = q->next->service;
                q->remain = q->next->remain;
                q->start = q->next->start;
                q->finish = q->next->finish;
                q->turnaround = q->next->turnaround;

                q->next->id = temp_id;
                q->next->priority = temp_priority;
                q->next->arrival = temp_arrival;
                q->next->service = temp_service;
                q->next->remain= temp_remain;
                q->next->start= temp_start;
                q->next->finish = temp_finish;
                q->next->turnaround = temp_turnaround;
            }
        }
    }
}

// 按照优先数对就绪队列进行排序的函数（冒泡排序）
void sort_by_priority() {
    process *p, *q;
    for (p = head; p != NULL; p = p->next) {
        for (q = head; q != tail; q = q->next) {
            if (q->priority < q->next->priority) {
                // 交换两个相邻节点的数据域（不交换指针域）
                int temp_id = q->id;
                int temp_priority = q->priority;
                int temp_arrival = q->arrival;
                int temp_service = q->service;
                int temp_remain = q->remain;
                int temp_start = q->start;
                int temp_finish = q->finish;
                int temp_turnaround = q->turnaround;

                q->id = q->next->id;
                q->priority = q->next->priority;
                q->arrival = q->next->arrival;
                q->service = q->next->service;
                q->remain = q->next->remain;
                q->start = q->next->start;
                q->finish = q->next->finish;
                q->turnaround = q->next->turnaround;

                q->next->id= temp_id;
                q->next->priority= temp_priority;
                q->next->arrival = temp_arrival;
                q->next->service = temp_service;
                q->next->remain = temp_remain;
                q->next->start = temp_start;
                q->next->finish = temp_finish;
                q->next->turnaround = temp_turnaround;
            }
        }
    }
}

// 打印就绪队列中的进程信息的函数
void print_process() {
    process *p = head;
    printf("就绪队列中的进程信息如下：\n");
    printf("ID\t优先数\t到达时间\t服务时间\t剩余时间\t开始时间\t完成时间\t周转时间\n");
    while (p != NULL) {
        printf("%d\t%d\t%d\t\t%d\t\t%d\t\t%d\t\t%d\t\t%d\n", p->id, p->priority, p->arrival, p->service, p->remain, p->start, p->finish, p->turnaround);
        p = p->next;
    }
}

// 基于优先权的进程调度算法的函数
void priority_scheduling() {
    int time = 0; // 当前时间
    int count = 0; // 完成进程数
    double total_turnaround = 0; // 总周转时间
    double average_turnaround = 0; // 平均周转时间
    process *p; // 当前执行的进程

    while (count < n) {
        // 当还有未完成的进程时，循环执行以下步骤
        sort_by_arrival(); // 按照到达时间对就绪队列进行排序
        p = head; // 取出就绪队列的第一个进程作为当前执行的进程
        if (p == NULL) {
            // 如果就绪队列为空，说明没有到达的进程，时间直接跳到下一个到达的进程的到达时间
            time++;
            continue;
        }
        if (p->arrival > time) {
            // 如果当前执行的进程还没有到达，时间直接跳到该进程的到达时间
            time = p->arrival;
            continue;
        }
        head = head->next; // 将就绪队列的第一个进程移出就绪队列
        if (p->start == -1) {
            // 如果当前执行的进程是第一次执行，设置其开始时间为当前时间
            p->start = time;
        }
        if (p->remain <= q) {
            // 如果当前执行的进程剩余时间小于等于一个时间片，说明该进程可以在一个时间片内完成
            time += p->remain; // 时间增加该进程剩余时间
            p->remain = 0; // 剩余时间变为0
            p->finish = time; // 设置该进程的完成时间为当前时间
            p->turnaround = p->finish - p->arrival; // 计算该进程的周转时间为完成时间减去到达时间
            total_turnaround += p->turnaround; // 累加总周转时间
            count++; // 完成进程数加一
            printf("第%d个进程完成，ID=%d，优先数=%d，到达时间=%d，服务时间=%d，开始时间=%d，完成时间=%d，周转时间=%d\n", count, p->id, p->priority, p->arrival, p->service, p->start, p->finish, p->turnaround);
            free(p); // 释放该进程的内存空间
        } else {
            // 如果当前执行的进程剩余时间大于一个时间片，说明该进程还需要继续执行
            time += q; // 时间增加一个时间片
            p->remain -= q; // 剩余时间减去一个时间片
            p->priority--; // 优先数减一
            sort_by_priority(); // 按照优先数对就绪队列进行排序
            head = p; // 将当前执行的进程插入到就绪队列的合适位置
        }
        print_process(); // 打印就绪队列中的进程信息
    }
    average_turnaround = total_turnaround / n; // 计算平均周转时间为总周转时间除以进程个数
    printf("所有进程完成，总周转时间=%f，平均周转时间=%f\n", total_turnaround, average_turnaround);
}

// 主函数
int main() {
    create_process(); // 创建进程
    priority_scheduling(); // 基于优先权的进程调度算法
    return 0;
}