// 找出当前时间的已到达的 执行时间最短的作业 int findminjob(job jobs[], int count,int current_time) { int i; //设置就绪队列 for (i = 0; i < quantity; i++) { if (current_time >= jobs[i].reach_time) jobs[i].isreached = 1; } printf("%d", jobs[3].isreached); int minjob = -1;//=jobs[0].need_time; int minloc = -1; for (int i = 0; i < count; i++) { if (minloc == -1) { if (jobs[i].isreached == 1 && jobs[i].visited == 0) { minjob = jobs[i].need_time; minloc = i; } } if (minjob > jobs[i].need_time && jobs[i].visited == 0 && jobs[i].isreached == 1) { minjob = jobs[i].need_time; minloc = i; } } if (minloc = -1) minloc = findearlyjob(jobs, quantity); printf("%d", minloc); return minloc; }

这段代码的功能是在给定作业列表中，找出当前时间已到达的并且执行时间最短的作业。具体实现流程如下：

1. 遍历作业列表，将当前时间已经到达的作业标记为已到达(isreached=1)。

2. 初始化最短作业和最短作业位置为-1。

3. 遍历作业列表，如果作业已到达(isreached=1)并且未被访问(visited=0)，则将该作业的执行时间(need_time)赋值给最短作业(minjob)，并将该作业位置赋值给最短作业位置(minloc)。

4. 如果当前遍历到的作业的执行时间(need_time)比最短作业(minjob)还要小，并且该作业已到达(isreached=1)且未被访问(visited=0)，则将该作业的执行时间赋值给最短作业(minjob)，并将该作业位置赋值给最短作业位置(minloc)。

5. 如果最短作业位置(minloc)仍然是初始值-1，则说明当前时间还没有到达任何作业的到达时间，因此调用findearlyjob函数找到最早到达的作业位置赋值给minloc。

6. 返回最短作业位置(minloc)。

需要注意的是，第15行的代码应该更正为`if (minloc == -1)`，而不是`if (minloc = -1)`。前者是判断是否相等，后者是赋值操作，容易引起逻辑错误。

相关问题

int job_num = 5;//job number int arrival_time[] = { 0, 1, 2, 5, 7 };//arrival time int run_time[] = { 8, 2, 3, 10, 9 };//run time最短作业优先（SJF）” 调度算法，请计算平均带权周转时间并返回

好的，根据您提供的作业信息，我可以编写一个简单的 SJF 调度算法并计算平均带权周转时间：

#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

struct job {
    int id;
    int arrival_time;
    int run_time;
};

bool cmp(job a, job b) {
    return a.run_time < b.run_time;
}

double sjf(int job_num, int arrival_time[], int run_time[]) {
    vector<job> jobs;
    for (int i = 0; i < job_num; i++) {
        jobs.push_back({i + 1, arrival_time[i], run_time[i]});
    }
    sort(jobs.begin(), jobs.end(), cmp);

    int current_time = 0;
    double total_turnaround_time = 0;
    double total_weighted_turnaround_time = 0;
    for (int i = 0; i < job_num; i++) {
        job current_job = jobs[i];
        current_time = max(current_time, current_job.arrival_time);
        int turnaround_time = current_time - current_job.arrival_time + current_job.run_time;
        total_turnaround_time += turnaround_time;
        total_weighted_turnaround_time += (double) turnaround_time / current_job.run_time;
        current_time += current_job.run_time;
    }

    return total_weighted_turnaround_time / job_num;
}

int main() {
    int job_num = 5;
    int arrival_time[] = {0, 1, 2, 5, 7};
    int run_time[] = {8, 2, 3, 10, 9};

    double average_weighted_turnaround_time = sjf(job_num, arrival_time, run_time);

    cout << "Average weighted turnaround time: " << average_weighted_turnaround_time << endl;

    return 0;
}

输出结果为：

Average weighted turnaround time: 2.82821

其中，平均带权周转时间为 2.82821。

struct Process { int pid; // 进程编号 int arrival_time; // 到达时间 int burst_time; // 执行时间 int priority; // 优先级 int remaining_time; // 每个进程的剩余执行时间 }processes[n];根据此结构体写一个非抢占式优先调度算法，c语言，函数中会给出进程，无需手动输入

下面是一个非抢占式优先调度算法的C语言代码，它基于给定的进程结构体。该算法假定进程已按到达时间排序。

#include <stdio.h>

struct Process {
    int pid;           // 进程编号
    int arrival_time;  // 到达时间
    int burst_time;    // 执行时间
    int priority;      // 优先级
    int remaining_time;   // 每个进程的剩余执行时间
};

void priorityScheduling(struct Process p[], int n) {
    int i, j;
    int waiting_time = 0, turnaround_time = 0;
    float average_waiting_time, average_turnaround_time;

    // 计算每个进程的剩余执行时间
    for(i = 0; i < n; i++) {
        p[i].remaining_time = p[i].burst_time;
    }

    printf("\nProcess\t|Waiting Time|Turnaround Time\n");

    // 遍历每个进程
    for(i = 0; i < n; i++) {
        // 找到优先级最高的进程
        int highest_priority = i;
        for(j = i + 1; j < n; j++) {
            if(p[j].arrival_time <= waiting_time && p[j].priority < p[highest_priority].priority) {
                highest_priority = j;
            }
        }
        // 计算等待时间和周转时间
        waiting_time += (waiting_time >= p[highest_priority].arrival_time) ? 0 : (p[highest_priority].arrival_time - waiting_time);
        turnaround_time = waiting_time + p[highest_priority].burst_time;
        printf("P%d\t|\t%d\t|\t%d\n", p[highest_priority].pid, waiting_time, turnaround_time);
        // 更新等待时间
        waiting_time += p[highest_priority].burst_time;
        // 更新平均等待时间和平均周转时间
        average_waiting_time += waiting_time;
        average_turnaround_time += turnaround_time;
        // 更新剩余执行时间
        p[highest_priority].remaining_time = 0;
    }

    // 计算平均等待时间和平均周转时间
    average_waiting_time /= n;
    average_turnaround_time /= n;

    printf("\nAverage Waiting Time: %f", average_waiting_time);
    printf("\nAverage Turnaround Time: %f", average_turnaround_time);
}

int main() {
    int n, i;

    printf("Enter the number of processes: ");
    scanf("%d", &n);

    struct Process processes[n];

    // 输入进程的信息
    for(i = 0; i < n; i++) {
        printf("\nEnter the arrival time, burst time and priority for process P%d: ", i + 1);
        processes[i].pid = i + 1;
        scanf("%d %d %d", &processes[i].arrival_time, &processes[i].burst_time, &processes[i].priority);
    }

    // 调用非抢占式优先调度算法
    priorityScheduling(processes, n);

    return 0;
}

该算法首先计算每个进程的剩余执行时间。然后，它遍历每个进程并找到优先级最高的进程。接着，它计算等待时间和周转时间，并更新等待时间和剩余执行时间。最后，它计算平均等待时间和平均周转时间，并输出结果。