CODE-

#include<stdio.h>

#include<stdlib.h>

#include <stdbool.h>

typedef struct{

int id,arrival,burst,completion,turnaround,remain,wait,priority,done;

}Process;

typedef struct{

int *p;

int front;

int rear;

int capacity;

}queue;

queue* getqueue(int cap)

queue* q=malloc(sizeof(queue));

q->front=-1;

q->rear=-1;

q->capacity=cap;

q->p=malloc(cap*sizeof(int));

return q;

bool isempty(queue* q)

if(q->front==-1 && q->rear ==-1)

return true;

return false;

}
bool isfull(queue *q)

if(q->rear==q->capacity-1)

return true;

return false;

void enqueue(queue *q,int i)

if(isfull(q))

printf("Cannot Able to insert");

return;

else if(isempty(q))

q->front++;

q->rear++;

q->p[q->rear]=i;

else{

q->rear++;

q->p[q->rear]=i;

int dequeue(queue *q)

if(isempty(q))

printf("Queue is empty\n");

return -1;
 }

int ele=q->p[q->front];

if(q->front==q->rear)

q->front=-1;

q->rear=-1;

else{

for (int i = q->front; i < q->rear; i++) {

q->p[i] = q->p[i + 1];

q->rear--;

return ele;

void addarrivals(Process *arr,int n,int currtime,queue *q,int *inqueue)

for(int i=0;i<n;i++)

if(arr[i].remain>0 &&!inqueue[i] && arr[i].arrival<=currtime)

enqueue(q,i);

inqueue[i]=1;

void printTable(Process *p, int n) {

int totalWT = 0, totalTAT = 0;

printf("\nPID\tAT\tBT\tPR\tCT\tTAT\tWT\n");
 for (int i = 0; i < n; i++) {

printf("%d\t%d\t%d\t%d\t%d\t%d\t%d\n",

p[i].id, p[i].arrival, p[i].burst, p[i].priority,

p[i].completion, p[i].turnaround, p[i].wait);

totalWT += p[i].wait;

totalTAT += p[i].turnaround;

printf("\nAverage WT = %.2f", (float)totalWT / n);

printf("\nAverage TAT = %.2f\n", (float)totalTAT / n);

void roundrobin(Process *arr,int n)

printf("Enter the Time Quantum");

int timequantum;

scanf("%d",&timequantum);

int currtime=0;

int completed=0;

int *inqueue=calloc(n,sizeof(int));

queue*q=getqueue(n);

addarrivals(arr,n,currtime,q,inqueue);

while(completed<n)

int idx=dequeue(q);

if(idx==-1)

currtime++;

addarrivals(arr,n,currtime,q,inqueue);
 continue;

int exectime=(arr[idx].remain<timequantum)? arr[idx].remain:timequantum;

arr[idx].remain=arr[idx].remain-exectime;

currtime+=exectime;

addarrivals(arr,n,currtime,q,inqueue);

if(arr[idx].remain==0)

completed++;

// inqueue[idx]=0;

arr[idx].completion=currtime;

arr[idx].turnaround=arr[idx].completion-arr[idx].arrival;

arr[idx].wait=arr[idx].turnaround-arr[idx].burst;

else{

enqueue(q,idx);

printTable(arr,n);

void sortOnArrivaltime(Process *arr,int n)

for(int i=0;i<n-1;i++)

for(int j=0;j<n-i-1;j++)

if(arr[j].arrival>arr[j+1].arrival)

Process p=arr[j];

arr[j]=arr[j+1];
 arr[j+1]=p;

void fcfs(Process *arr,int n)

sortOnArrivaltime(arr,n);

int currtime=0;

currtime=arr[0].arrival;

for(int i=0;i<n;i++)

currtime+=arr[i].burst;

arr[i].completion=currtime;

arr[i].turnaround=arr[i].completion-arr[i].arrival;

arr[i].wait=arr[i].turnaround-arr[i].burst;

if(i+1<n && currtime<arr[i].arrival)

int t=arr[i].arrival-currtime;

currtime+=t;

printTable(arr,n);

void sjfNonPreemptive(Process *arr,int n)

sortOnArrivaltime(arr,n);

int currtime=0;

int completed=0;
while(completed<n)

int minburst=1e9;

int currindx=-1;

for(int i=0;i<n;i++)

if(arr[i].arrival<=currtime &&!arr[i].done)

if(arr[i].burst<minburst)

minburst=arr[i].burst;

currindx=i;

else if(arr[i].burst==minburst && arr[i].arrival<arr[currindx].arrival)

currindx=i;

if(currindx==-1)

currtime++;

else{

currtime+=arr[currindx].burst;

arr[currindx].completion=currtime;

arr[currindx].done=1;

completed++;

arr[currindx].turnaround=arr[currindx].completion-arr[currindx].arrival;

arr[currindx].wait=arr[currindx].turnaround-arr[currindx].burst;

printTable(arr,n);
}

void sjfpreemptive(Process *arr,int n)

int currtime=0;

int processdone=0;

while(processdone<n)

int currprocess=-1;

for(int i=0;i<n;i++)

if(arr[i].arrival<=currtime && arr[i].remain>0 && (currprocess==-1 || arr[i].remain<arr[currprocess].remain))

currprocess=i;

if(currprocess!=-1)

arr[currprocess].remain--;

currtime++;

if(arr[currprocess].remain==0)

arr[currprocess].completion=currtime;

arr[currprocess].turnaround=arr[currprocess].completion-arr[currprocess].arrival;

arr[currprocess].wait=arr[currprocess].turnaround-arr[currprocess].burst;

processdone++;

else{

currtime++;

}
}

printTable(arr,n);

void sortArrivalandPriority(Process *arr,int n)

for(int i=0;i<n-1;i++)

for(int j=0;j<n-i-1;j++)

if(arr[j].arrival>arr[j+1].arrival ||(arr[j].arrival==arr[j+1].arrival &&arr[j].priority>arr[j+1].priority))

Process p=arr[j];

arr[j]=arr[j+1];

arr[j+1]=p;

void priorityNonPreemptive(Process *arr,int n)

sortArrivalandPriority(arr,n);

int currtime=0;

int completed=0;

while(completed<n)

int idx=-1;

int bestpriority=9999990;

for(int i=0;i<n;i++)

if(!arr[i].done && currtime>=arr[i].arrival)

if(bestpriority>arr[i].priority)

bestpriority=arr[i].priority;

idx=i;

if(idx==-1)

currtime++;

continue;

currtime+=arr[idx].burst;

arr[idx].completion=currtime;

arr[idx].turnaround=arr[idx].completion-arr[idx].arrival;

arr[idx].wait=arr[idx].turnaround-arr[idx].burst;

arr[idx].done=1;

completed++;

printTable(arr,n);

void proritypreemptive(Process *arr,int n)

int currtime = 0, completed = 0;

while (completed < n) {

int idx = -1;

int bestpriority = 999999;

for (int i = 0; i < n; i++) {

if (arr[i].remain > 0 && currtime >= arr[i].arrival) {

if (arr[i].priority < bestpriority) {

idx = i;

else if (arr[i].priority == bestpriority) {

// Tie-breaking: earlier arrival

if (arr[i].arrival < arr[idx].arrival) {

idx = i;

// If same arrival, smaller PID wins

else if (arr[i].arrival == arr[idx].arrival && arr[i].id < arr[idx].id) {

idx = i;

if (idx == -1) {

currtime++; // no process available, idle

continue;

// Execute process for 1 unit (preemptive)

arr[idx].remain--;

currtime++;

// If process finished

if (arr[idx].remain == 0) {

arr[idx].completion = currtime;

arr[idx].turnaround = arr[idx].completion - arr[idx].arrival;

arr[idx].wait = arr[idx].turnaround - arr[idx].burst;

completed++;

printTable(arr,n);
}

int main()

printf("Enter the Number of Process");

int n;

scanf("%d",&n);

Process *arr=malloc(n*sizeof(Process));

for(int i=0;i<n;i++)

arr[i].id=i+1;

printf("Enter the Arrival Time and Burst Time and Priority");

scanf("%d %d %d", &arr[i].arrival, &arr[i].burst,&arr[i].priority);

arr[i].remain=arr[i].burst;

arr[i].done=0;

printf("Enter the scheduling algorithm to perform:\n");

printf("1. FCFS\n2. SJF Non-Preemptive\n3. SJF Preemptive\n4. Priority Non-Preemptive\n5. Priority Preemptive\n6.
Round Robin\n");

int ch;

scanf("%d",&ch);

switch(ch)

case 1:

fcfs(arr,n);

break;

case 2:

sjfNonPreemptive(arr,n);

break;

case 3:
 sjfpreemptive(arr,n);

break;

case 4:

priorityNonPreemptive(arr,n);

break;

case 5:

proritypreemptive(arr,n);

break;

case 6:

roundrobin(arr,n);

break;

default:

printf("Invalid Choice");