RoundRobin.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// Process structure (Node of circular linked list)
struct Process {
    int pid;              // Process ID
    int burst_time;       // Remaining burst time
    int waiting_time;     
    int turnaround_time;  
    int completed;        
    struct Process *next; // Pointer to next process (circular)
};

// Function to create a new process node
struct Process* createProcess(int pid, int burst_time) {
    struct Process* newProcess = (struct Process*)malloc(sizeof(struct Process));
    newProcess->pid = pid;
    newProcess->burst_time = burst_time;
    newProcess->waiting_time = 0;
    newProcess->turnaround_time = 0;
    newProcess->completed = 0;
    newProcess->next = NULL;
    return newProcess;
}

// Function to add process to circular linked list
void addProcess(struct Process** head, int pid, int burst_time) {
    struct Process* newProcess = createProcess(pid, burst_time);
    if (*head == NULL) {
        *head = newProcess;
        newProcess->next = *head; // circular
    } else {
        struct Process* temp = *head;
        while (temp->next != *head)
            temp = temp->next;
        temp->next = newProcess;
        newProcess->next = *head;
    }
}

// Round Robin Scheduling function
void roundRobin(struct Process* head, int time_quantum) {
    int time = 0, completed = 0, n = 0;
    struct Process* temp = head;

    // Count number of processes
    do {
        n++;
        temp = temp->next;
    } while (temp != head);

    printf("\n--- Round Robin CPU Scheduling ---\n");
    printf("Gantt Chart: \n");

    temp = head;
    while (completed < n) {
        if (temp->burst_time > 0) {
            printf("| P%d ", temp->pid);
            if (temp->burst_time > time_quantum) {
                time += time_quantum;
                temp->burst_time -= time_quantum;
            } else {
                time += temp->burst_time;
                temp->waiting_time = time - temp->turnaround_time - temp->burst_time;
                temp->burst_time = 0;
                temp->completed = 1;
                temp->turnaround_time = time;
                completed++;
            }
        }
        temp = temp->next;
    }
    printf("|\n");

    // Print results
    printf("\nProcess\tWaiting Time\tTurnaround Time\n");
    float totalWT = 0, totalTAT = 0;
    temp = head;
    do {
        printf("P%d\t%d\t\t%d\n", temp->pid, temp->waiting_time, temp->turnaround_time);
        totalWT += temp->waiting_time;
        totalTAT += temp->turnaround_time;
        temp = temp->next;
    } while (temp != head);

    printf("\nAverage Waiting Time: %.2f", totalWT / n);
    printf("\nAverage Turnaround Time: %.2f\n", totalTAT / n);
}

// Main function
int main() {
    struct Process* head = NULL;
    int n, i, bt, tq;

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

    for (i = 1; i <= n; i++) {
        printf("Enter burst time for Process %d: ", i);
        scanf("%d", &bt);
        addProcess(&head, i, bt);
    }

    printf("Enter Time Quantum: ");
    scanf("%d", &tq);

    roundRobin(head, tq);

    return 0;
}