非抢占式短进程优先算法c语言怎么写

非抢占式短进程优先算法的C语言实现如下：

#include <stdio.h>

struct Process
{
    int arrival_time;  // 到达时间
    int burst_time;    // 执行时间
    int waiting_time;  // 等待时间
    int turnaround_time;  // 周转时间
};

void calculate_times(struct Process p[], int n);

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

    struct Process p[n];

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

    calculate_times(p, n);

    // 输出每个进程的信息
    printf("进程号\t到达时间\t执行时间\t等待时间\t周转时间\n");
    for (int i = 0; i < n; i++)
    {
        printf("%d\t%d\t%d\t\t%d\t\t%d\n", i + 1, p[i].arrival_time, p[i].burst_time,
               p[i].waiting_time, p[i].turnaround_time);
    }

    return 0;
}

void calculate_times(struct Process p[], int n)
{
    int t = 0;  // 当前时间
    int completed_processes = 0;  // 完成的进程数

    while (completed_processes < n)
    {
        int shortest_job_index = -1;
        int shortest_job_burst_time = 1000000;  // 假设一个很大的值

        // 找到最短的可执行进程
        for (int i = 0; i < n; i++)
        {
            if (p[i].burst_time > 0 && p[i].arrival_time <= t &&
                p[i].burst_time < shortest_job_burst_time)
            {
                shortest_job_index = i;
                shortest_job_burst_time = p[i].burst_time;
            }
        }

        if (shortest_job_index == -1)  // 没有可执行的进程
        {
            t++;
        }
        else
        {
            p[shortest_job_index].burst_time--;  // 执行该进程
            t++;

            if (p[shortest_job_index].burst_time == 0)  // 进程完成
            {
                completed_processes++;
                p[shortest_job_index].waiting_time = t - p[shortest_job_index].arrival_time -
                                                      p[shortest_job_index].turnaround_time;
                p[shortest_job_index].turnaround_time = t - p[shortest_job_index].arrival_time;
            }
        }
    }
}

该算法的思路是不断找到最短的可执行进程，先执行该进程，若该进程执行完则计算其等待时间和周转时间。