os

1. FCFS — First Come First Serve
#include<stdio.h>

int main()
{
    int p[20],at[20],bt[20],ct[20],tat[20],wt[20];
    int i,j,n,temp;
    float awt=0,atat=0;

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

    for(i=0;i<n;i++)
    {
        printf("Enter process number: ");
        scanf("%d",&p[i]);
    }

    for(i=0;i<n;i++)
    {
        printf("Enter arrival time for P%d: ",p[i]);
        scanf("%d",&at[i]);
    }

    for(i=0;i<n;i++)
    {
        printf("Enter burst time for P%d: ",p[i]);
        scanf("%d",&bt[i]);
    }

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

                temp=bt[j];
                bt[j]=bt[j+1];
                bt[j+1]=temp;

                temp=p[j];
                p[j]=p[j+1];
                p[j+1]=temp;
            }
        }
    }

    ct[0]=at[0]+bt[0];

    for(i=1;i<n;i++)
    {
        if(ct[i-1]<at[i])
            ct[i]=at[i]+bt[i];
        else
            ct[i]=ct[i-1]+bt[i];
    }

    for(i=0;i<n;i++)
    {
        tat[i]=ct[i]-at[i];
        wt[i]=tat[i]-bt[i];
        atat+=tat[i];
        awt+=wt[i];
    }

    atat/=n;
    awt/=n;

    printf("\nProcess\tAT\tBT\tCT\tTAT\tWT\n");

    for(i=0;i<n;i++)
        printf("P%d\t%d\t%d\t%d\t%d\t%d\n",p[i],at[i],bt[i],ct[i],tat[i],wt[i]);

    printf("\nAverage Turnaround Time = %.2f",atat);
    printf("\nAverage Waiting Time = %.2f\n",awt);

    return 0;
}
2. SJF — Non-Preemptive

Important: This version considers arrival time, so it correctly handles processes that haven't arrived yet.

#include<stdio.h>

int main()
{
    int p[20],at[20],bt[20],ct[20],tat[20],wt[20],done[20];
    int i,n,time=0,count=0,pos;
    float awt=0,atat=0;

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

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

        printf("Enter arrival time for P%d: ",p[i]);
        scanf("%d",&at[i]);

        printf("Enter burst time for P%d: ",p[i]);
        scanf("%d",&bt[i]);
    }

    while(count<n)
    {
        pos=-1;

        for(i=0;i<n;i++)
        {
            if(done[i]==0 && at[i]<=time)
            {
                if(pos==-1 || bt[i]<bt[pos])
                    pos=i;
            }
        }

        if(pos==-1)
        {
            time++;
            continue;
        }

        time+=bt[pos];
        ct[pos]=time;
        tat[pos]=ct[pos]-at[pos];
        wt[pos]=tat[pos]-bt[pos];

        done[pos]=1;
        count++;

        awt+=wt[pos];
        atat+=tat[pos];
    }

    printf("\nProcess\tAT\tBT\tCT\tTAT\tWT\n");

    for(i=0;i<n;i++)
        printf("P%d\t%d\t%d\t%d\t%d\t%d\n",p[i],at[i],bt[i],ct[i],tat[i],wt[i]);

    printf("\nAverage Waiting Time = %.2f",awt/n);
    printf("\nAverage Turnaround Time = %.2f\n",atat/n);

    return 0;
}
Key idea

Once a process starts, it runs completely.

Shortest available job → runs completely → next shortest
3. SJF — Preemptive / SRTF

Preemptive SJF is also called Shortest Remaining Time First (SRTF).

#include<stdio.h>

int main()
{
    int p[20],at[20],bt[20],rt[20],ct[20],tat[20],wt[20];
    int i,n,time=0,count=0,smallest;
    float awt=0,atat=0;

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

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

        printf("Enter arrival time for P%d: ",p[i]);
        scanf("%d",&at[i]);

        printf("Enter burst time for P%d: ",p[i]);
        scanf("%d",&bt[i]);

        rt[i]=bt[i];
    }

    while(count<n)
    {
        smallest=-1;

        for(i=0;i<n;i++)
        {
            if(at[i]<=time && rt[i]>0)
            {
                if(smallest==-1 || rt[i]<rt[smallest])
                    smallest=i;
            }
        }

        if(smallest==-1)
        {
            time++;
            continue;
        }

        rt[smallest]--;
        time++;

        if(rt[smallest]==0)
        {
            count++;

            ct[smallest]=time;
            tat[smallest]=ct[smallest]-at[smallest];
            wt[smallest]=tat[smallest]-bt[smallest];

            awt+=wt[smallest];
            atat+=tat[smallest];
        }
    }

    printf("\nProcess\tAT\tBT\tCT\tTAT\tWT\n");

    for(i=0;i<n;i++)
        printf("P%d\t%d\t%d\t%d\t%d\t%d\n",p[i],at[i],bt[i],ct[i],tat[i],wt[i]);

    printf("\nAverage Waiting Time = %.2f",awt/n);
    printf("\nAverage Turnaround Time = %.2f\n",atat/n);

    return 0;
}
Key idea

Every 1 unit of time, the CPU checks which available process has the shortest remaining burst time.

So a newly arrived shorter process can interrupt the currently running process.

4. Round Robin

This is the simple version with arrival time + time quantum + table output.

#include<stdio.h>

int main()
{
    int p[20],at[20],bt[20],rt[20],ct[20],tat[20],wt[20];
    int i,n,time=0,count=0,done;
    int tq;
    float awt=0,atat=0;

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

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

        printf("Enter arrival time for P%d: ",p[i]);
        scanf("%d",&at[i]);

        printf("Enter burst time for P%d: ",p[i]);
        scanf("%d",&bt[i]);

        rt[i]=bt[i];
    }

    printf("Enter time quantum: ");
    scanf("%d",&tq);

    while(count<n)
    {
        done=0;

        for(i=0;i<n;i++)
        {
            if(at[i]<=time && rt[i]>0)
            {
                done=1;

                if(rt[i]>tq)
                {
                    time+=tq;
                    rt[i]-=tq;
                }
                else
                {
                    time+=rt[i];
                    rt[i]=0;

                    ct[i]=time;
                    tat[i]=ct[i]-at[i];
                    wt[i]=tat[i]-bt[i];

                    awt+=wt[i];
                    atat+=tat[i];

                    count++;
                }
            }
        }

        if(done==0)
            time++;
    }

    printf("\nProcess\tAT\tBT\tCT\tTAT\tWT\n");

    for(i=0;i<n;i++)
        printf("P%d\t%d\t%d\t%d\t%d\t%d\n",p[i],at[i],bt[i],ct[i],tat[i],wt[i]);

    printf("\nAverage Waiting Time = %.2f",awt/n);
    printf("\nAverage Turnaround Time = %.2f\n",atat/n);

    return 0;
}