SJF & SRTF Scheduling in OS

#include <stdio.h>

#define MAX 100

struct Process {
    int pid, arrival, burst, start, remaining, completion, waiting, turnaround, visited;
};

void sortByArrival(struct Process p[], int n) {
    struct Process temp;
    for (int i = 0; i < n - 1; ++i)
        for (int j = 0; j < n - i - 1; ++j)
            if (p[j].arrival > p[j + 1].arrival) {
                temp = p[j];
                p[j] = p[j + 1];
                p[j + 1] = temp;
            }
}

void sjf_non_preemptive(struct Process p[], int n) {
    int current = 0, completed = 0;
    while (completed < n) {
        int idx = -1, min_burst = 9999;
        for (int i = 0; i < n; i++) {
            if (!p[i].visited && p[i].arrival <= current && p[i].burst < min_burst) {
                min_burst = p[i].burst;
                idx = i;
            }
        }
        if (idx != -1) {
            p[idx].start = current;
            p[idx].completion = p[idx].start + p[idx].burst;
            p[idx].turnaround = p[idx].completion - p[idx].arrival;
            p[idx].waiting = p[idx].turnaround - p[idx].burst;
            p[idx].visited = 1;
            current = p[idx].completion;
            completed++;
        } else {
            current++;
        }
    }
}

int findShortest(int n, struct Process p[], int current_time) {
    int min = 9999, idx = -1;
    for (int i = 0; i < n; i++) {
        if (p[i].arrival <= current_time && p[i].remaining > 0 && p[i].remaining < min) {
            min = p[i].remaining;
            idx = i;
        }
    }
    return idx;
}

void sjf_preemptive(struct Process p[], int n, int timeline[], int *total_time) {
    int time = 0, completed = 0;
    while (completed < n) {
        int idx = findShortest(n, p, time);
        timeline[time] = (idx == -1) ? -1 : p[idx].pid;
        if (idx != -1) {
            p[idx].remaining--;
            if (p[idx].remaining == 0) {
                p[idx].completion = time + 1;
                p[idx].turnaround = p[idx].completion - p[idx].arrival;
                p[idx].waiting = p[idx].turnaround - p[idx].burst;
                completed++;
            }
        }
        time++;
    }
    *total_time = time;
}

void print_table(struct Process p[], int n) {
    float total_wt = 0, total_tt = 0;
    printf("\nPID  Arrival  Burst  Waiting  Turnaround  Completion\n");
    for (int i = 0; i < n; i++) {
        printf("P%-3d %-8d%-7d%-9d%-12d%-10d\n", p[i].pid, p[i].arrival, p[i].burst,
               p[i].waiting, p[i].turnaround, p[i].completion);
        total_wt += p[i].waiting;
        total_tt += p[i].turnaround;
    }
    printf("\nAverage Waiting Time = %.2f\n", total_wt / n);
    printf("Average Turnaround Time = %.2f\n", total_tt / n);
}

void print_gantt_chart_np(struct Process p[], int n) {
    printf("\nGantt Chart (Non-Preemptive):\n ");
    for (int i = 0; i < n; i++) printf("--------");
    printf("-\n|");
    for (int i = 0; i < n; i++) printf("  P%-2d |", p[i].pid);
    printf("\n ");
    for (int i = 0; i < n; i++) printf("--------");
    printf("-\n%d", p[0].start);
    for (int i = 0; i < n; i++) printf("       %d", p[i].completion);
    printf("\n");
}

void print_gantt_chart_pt(int timeline[], int total_time) {
    printf("\nGantt Chart (Preemptive):\n ");
    for (int i = 0; i < total_time; i++) {
        if (i == 0 || timeline[i] != timeline[i - 1]) printf("------");
    }
    printf("-\n|");
    for (int i = 0; i < total_time; i++) {
        if (i == 0 || timeline[i] != timeline[i - 1])
            if (timeline[i] == -1) printf(" IDLE |");
            else printf(" P%-2d |", timeline[i]);
    }
    printf("\n ");
    for (int i = 0; i < total_time; i++) {
        if (i == 0 || timeline[i] != timeline[i - 1]) printf("------");
    }
    printf("-\n0");
    for (int i = 1; i < total_time; i++) {
        if (timeline[i] != timeline[i - 1])
            printf("     %2d", i);
    }
    printf("     %2d\n", total_time);
}

int main() {
    int n, choice;
    struct Process p[MAX];
    int timeline[MAX], total_time = 0;

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

    for (int i = 0; i < n; i++) {
        p[i].pid = i + 1;
        p[i].visited = 0;
        printf("Enter Arrival Time and Burst Time for P%d: ", p[i].pid);
        scanf("%d %d", &p[i].arrival, &p[i].burst);
        p[i].remaining = p[i].burst;
    }

    printf("\nChoose Scheduling Algorithm:\n1. Non-Preemptive SJF\n2. Preemptive SJF (SRTF)\nEnter choice: ");
    scanf("%d", &choice);

    if (choice == 1) {
        sortByArrival(p, n);
        sjf_non_preemptive(p, n);
        print_table(p, n);
        print_gantt_chart_np(p, n);
    } else if (choice == 2) {
        sjf_preemptive(p, n, timeline, &total_time);
        print_table(p, n);
        print_gantt_chart_pt(timeline, total_time);
    } else {
        printf("Invalid choice.\n");
    }

    return 0;
}