短进程优先调度算法C++

短进程优先调度算法（Shortest Job First，简称 SJF）是一种非抢占式的调度算法。它根据进程的估计运行时间来选择下一个要运行的进程，即先运行预计运行时间最短的进程。

下面是一个简单的 C++ 实现：

#include <iostream> 
using namespace std; 

int main() 
{ 
    int n, i, j, temp, sum = 0; 
    float avg_wt, avg_tat; 

    cout << "Enter the number of processes: "; 
    cin >> n; 

    int bt[n], wt[n], tat[n]; 

    for(i = 0; i < n; i++) 
    { 
        cout << "Enter the burst time of process " << i+1 << ": "; 
        cin >> bt[i]; 
    } 

    for(i = 0; i < n; i++) 
    { 
        for(j = i+1; j < n; j++) 
        { 
            if(bt[i] > bt[j]) 
            { 
                temp = bt[i]; 
                bt[i] = bt[j]; 
                bt[j] = temp; 
            } 
        } 
    } 

    wt[0] = 0; 

    for(i = 1; i < n; i++) 
    { 
        wt[i] = 0; 

        for(j = 0; j < i; j++) 
            wt[i] += bt[j]; 

        sum += wt[i]; 
    } 

    avg_wt = (float)sum/n; 
    sum = 0; 

    cout << "\nProcess\t\tBurst Time\tWaiting Time\tTurnaround Time"; 

    for(i = 0; i < n; i++) 
    { 
        tat[i] = bt[i] + wt[i]; 
        sum += tat[i]; 
        cout << "\nP" << i+1 << "\t\t" << bt[i] << "\t\t" << wt[i] << "\t\t" << tat[i]; 
    } 

    avg_tat = (float)sum/n; 

    cout << "\n\nAverage Waiting Time = " << avg_wt; 
    cout << "\nAverage Turnaround Time = " << avg_tat; 

    return 0; 
} 

在这个实现中，我们首先输入进程的数量和它们的 burst time（执行时间），然后对它们按照 burst time 进行排序。接着计算每个进程的 waiting time（等待时间），并且计算它们的 turnaround time（周转时间）。最后，我们计算平均等待时间和平均周转时间，并输出它们。

需要注意的是，这个实现假设所有进程的 burst time 都是已知的，而实际上通常情况下我们并不知道每个进程需要运行多长时间。因此，在实际使用 SJF 调度算法时，我们需要使用一些估算技术来估计每个进程的执行时间。