├── FCFS Scheduling Algorithm Without Arrival Time.c
├── LICENSE
├── SJF Scheduling Algorithm Without Arrival Time.c
├── FCFS Scheduling Algorithm.c
├── Non-Preemptive Priority Scheduling (Highest Priority First) Without ArrivalTime Algorithm.c
├── Non-Preemptive Priority Scheduling (Smallest Priority First) Without ArrivalTime Algorithm.c
├── SRTF Scheduling Algorithm.c
├── Non-Preemptive Priority Scheduling (Highest Priority First) Algorithm.c
├── Non-Preemptive Priority Scheduling (Smallest Priority First) Algorithm.c
├── Round Robin Scheduling Algorithm.c
├── Highest Response Ratio Next (HRRN) Scheduling Algorithm.c
├── SJF Scheduling Algorithm.c
├── Preemptive Priority Scheduling (Highest Priority First) Algorithm.c
├── Preemptive Priority Scheduling (Smallest Priority First) Algorithm.c
├── Round Robin (Queue Implementation) Scheduling Algorithm.c
└── README.md


/FCFS Scheduling Algorithm Without Arrival Time.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | struct proc
 3 | {
 4 |     int no,bt,ct,tat,wt;
 5 | };
 6 | struct proc read(int i)
 7 | {
 8 |     struct proc p;
 9 |     printf("\nProcess No: %d\n",i);
10 |     p.no=i;
11 |     printf("Enter Burst Time: ");
12 |     scanf("%d",&p.bt);
13 |     return p;
14 | }
15 | int main()
16 | {
17 |     struct proc p[10],tmp;
18 |     float avgtat=0,avgwt=0;
19 |     int n,ct=0;
20 |     printf("<--FCFS Scheduling Algorithm Without Arrival Time (Non-Preemptive)-->\n");
21 |     printf("Enter Number of Processes: ");
22 |     scanf("%d",&n);
23 |     for(int i=0;i<n;i++)
24 |         p[i]=read(i+1);
25 |     printf("\nProcessNo\tBT\tCT\tTAT\tWT\tRT\n");
26 |     for(int i=0;i<n;i++)
27 |     {
28 |         ct+=p[i].bt;
29 | 		p[i].ct=p[i].tat=ct;
30 |         avgtat+=p[i].tat;
31 |         p[i].wt=p[i].tat-p[i].bt;
32 |         avgwt+=p[i].wt;
33 |         printf("P%d\t\t%d\t%d\t%d\t%d\t%d\n",p[i].no,p[i].bt,p[i].ct,p[i].tat,p[i].wt,p[i].wt);
34 |     }
35 |     avgtat/=n,avgwt/=n;
36 |     printf("\nAverage TurnAroundTime=%f\nAverage WaitingTime=%f",avgtat,avgwt);
37 | }
38 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2020 https://github.com/PrakharPipersania/Scheduling-Algorithms
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/SJF Scheduling Algorithm Without Arrival Time.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | struct proc
 3 | {
 4 |     int no,bt,ct,tat,wt;
 5 | };
 6 | struct proc read(int i)
 7 | {
 8 |     struct proc p;
 9 |     printf("\nProcess No: %d\n",i);
10 |     p.no=i;
11 |     printf("Enter Burst Time: ");
12 |     scanf("%d",&p.bt);
13 |     return p;
14 | }
15 | int main()
16 | {
17 |     struct proc p[10],tmp;
18 |     float avgtat=0,avgwt=0;
19 |     int n,ct=0;
20 |     printf("<--SJF Scheduling Algorithm Without Arrival Time (Non-Preemptive)-->\n");
21 |     printf("Enter Number of Processes: ");
22 |     scanf("%d",&n);
23 |     for(int i=0;i<n;i++)
24 |         p[i]=read(i+1);
25 |     for(int i=0;i<n-1;i++)
26 |         for(int j=0;j<n-i-1;j++)    
27 |             if(p[j].bt>p[j+1].bt)
28 |             {
29 | 				tmp=p[j];
30 | 				p[j]=p[j+1];
31 | 				p[j+1]=tmp;
32 |             }
33 |     printf("\nProcessNo\tBT\tCT\tTAT\tWT\tRT\n");
34 |     for(int i=0;i<n;i++)
35 |     {
36 |         ct+=p[i].bt;
37 | 		p[i].ct=p[i].tat=ct;
38 | 		avgtat+=p[i].tat;
39 |         p[i].wt=p[i].tat-p[i].bt;
40 |         avgwt+=p[i].wt;
41 |         printf("P%d\t\t%d\t%d\t%d\t%d\t%d\n",p[i].no,p[i].bt,p[i].ct,p[i].tat,p[i].wt,p[i].wt);
42 |     }
43 |     avgtat/=n,avgwt/=n;
44 |     printf("\nAverage TurnAroundTime=%f\nAverage WaitingTime=%f",avgtat,avgwt);
45 | }
46 | 


--------------------------------------------------------------------------------
/FCFS Scheduling Algorithm.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | struct proc
 3 | {
 4 |     int no,at,bt,ct,tat,wt;
 5 | };
 6 | struct proc read(int i)
 7 | {
 8 |     struct proc p;
 9 |     printf("\nProcess No: %d\n",i);
10 |     p.no=i;
11 |     printf("Enter Arrival Time: ");
12 |     scanf("%d",&p.at);
13 |     printf("Enter Burst Time: ");
14 |     scanf("%d",&p.bt);
15 |     return p;
16 | }
17 | int main()
18 | {
19 |     struct proc p[10],tmp;
20 |     float avgtat=0,avgwt=0;
21 |     int n,ct=0;
22 |     printf("<--FCFS Scheduling Algorithm (Non-Preemptive)-->\n");
23 |     printf("Enter Number of Processes: ");
24 |     scanf("%d",&n);
25 |     for(int i=0;i<n;i++)
26 |         p[i]=read(i+1);
27 |     for(int i=0;i<n-1;i++)
28 |         for(int j=0;j<n-i-1;j++)    
29 |             if(p[j].at>p[j+1].at)
30 |             {
31 |             tmp=p[j];
32 |             p[j]=p[j+1];
33 |             p[j+1]=tmp;
34 |             }
35 |     printf("\nProcessNo\tAT\tBT\tCT\tTAT\tWT\tRT\n");
36 |     for(int i=0;i<n;i++)
37 |     {
38 |         ct+=p[i].bt;
39 | 		p[i].ct=ct;
40 |         p[i].tat=p[i].ct-p[i].at;
41 |         avgtat+=p[i].tat;
42 |         p[i].wt=p[i].tat-p[i].bt;
43 |         avgwt+=p[i].wt;
44 |         printf("P%d\t\t%d\t%d\t%d\t%d\t%d\t%d\n",p[i].no,p[i].at,p[i].bt,p[i].ct,p[i].tat,p[i].wt,p[i].wt);
45 |     }
46 |     avgtat/=n,avgwt/=n;
47 |     printf("\nAverage TurnAroundTime=%f\nAverage WaitingTime=%f",avgtat,avgwt);
48 | }
49 | 


--------------------------------------------------------------------------------
/Non-Preemptive Priority Scheduling (Highest Priority First) Without ArrivalTime Algorithm.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | struct proc
 3 | {
 4 |     int no,bt,ct,wt,tat,pri;
 5 | };
 6 | struct proc read(int i)
 7 | {
 8 |     struct proc p;
 9 |     printf("\nProcess No: %d\n",i);
10 |     p.no=i;
11 |     printf("Enter Burst Time: ");
12 |     scanf("%d",&p.bt);
13 |     printf("Enter Priority: ");
14 |     scanf("%d",&p.pri);
15 |     return p;
16 | }
17 | void main()
18 | {
19 |     int n,ct=0;
20 |     float avgtat=0,avgwt=0;
21 |     struct proc p[10],temp;
22 |     printf("<--Highest Priority First Scheduling Algorithm Without Arrival Time (Non-Preemptive)-->\n");
23 |     printf("Enter Number of Processes: ");
24 |     scanf("%d",&n);
25 |     for(int i=0;i<n;i++)
26 |         p[i]=read(i+1);
27 |     for(int i=0;i<n-1;i++)
28 |         for(int j=0;j<n-i-1;j++)    
29 |             if(p[j].pri<p[j+1].pri)
30 |             {
31 |             temp=p[j];
32 |             p[j]=p[j+1];
33 |             p[j+1]=temp;
34 |             }
35 |     printf("\nProcess\t\tBT\tPri\tCT\tTAT\tWT\n");
36 |     for(int i=0;i<n;i++)
37 |     {
38 |         ct+=p[i].bt;
39 |         p[i].ct=p[i].tat=ct;
40 |         avgtat+=p[i].tat;
41 |         p[i].wt=p[i].tat-p[i].bt;
42 |         avgwt+=p[i].wt;
43 |         printf("P%d\t\t%d\t%d\t%d\t%d\t%d\n",p[i].no,p[i].bt,p[i].pri,p[i].ct,p[i].tat,p[i].wt);
44 |     }
45 |     avgtat/=n,avgwt/=n;
46 |     printf("\nAverage TurnAroundTime=%f\nAverage WaitingTime=%f",avgtat,avgwt);
47 | }


--------------------------------------------------------------------------------
/Non-Preemptive Priority Scheduling (Smallest Priority First) Without ArrivalTime Algorithm.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | struct proc
 3 | {
 4 |     int no,bt,ct,wt,tat,pri;
 5 | };
 6 | struct proc read(int i)
 7 | {
 8 |     struct proc p;
 9 |     printf("\nProcess No: %d\n",i);
10 |     p.no=i;
11 |     printf("Enter Burst Time: ");
12 |     scanf("%d",&p.bt);
13 |     printf("Enter Priority: ");
14 |     scanf("%d",&p.pri);
15 |     return p;
16 | }
17 | void main()
18 | {
19 |     int n,ct=0;
20 |     float avgtat=0,avgwt=0;
21 |     struct proc p[10],temp;
22 |     printf("<--Smaller Priority First Scheduling Algorithm Without Arrival Time (Non-Preemptive)-->\n");
23 |     printf("Enter Number of Processes: ");
24 |     scanf("%d",&n);
25 |     for(int i=0;i<n;i++)
26 |         p[i]=read(i+1);
27 |     for(int i=0;i<n-1;i++)
28 |         for(int j=0;j<n-i-1;j++)    
29 |             if(p[j].pri>p[j+1].pri)
30 |             {
31 |             temp=p[j];
32 |             p[j]=p[j+1];
33 |             p[j+1]=temp;
34 |             }
35 |     printf("\nProcess\t\tBT\tPri\tCT\tTAT\tWT\n");
36 |     for(int i=0;i<n;i++)
37 |     {
38 |         ct+=p[i].bt;
39 |         p[i].ct=p[i].tat=ct;
40 |         avgtat+=p[i].tat;
41 |         p[i].wt=p[i].tat-p[i].bt;
42 |         avgwt+=p[i].wt;
43 |         printf("P%d\t\t%d\t%d\t%d\t%d\t%d\n",p[i].no,p[i].bt,p[i].pri,p[i].ct,p[i].tat,p[i].wt);
44 |     }
45 |     avgtat/=n,avgwt/=n;
46 |     printf("\nAverage TurnAroundTime=%f\nAverage WaitingTime=%f",avgtat,avgwt);
47 | }


--------------------------------------------------------------------------------
/SRTF Scheduling Algorithm.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #define MAX 9999
 3 | struct proc
 4 | {
 5 |     int no,at,bt,rt,ct,tat,wt;
 6 | };
 7 | struct proc read(int i)
 8 | {
 9 |     struct proc p;
10 |     printf("\nProcess No: %d\n",i);
11 |     p.no=i;
12 |     printf("Enter Arrival Time: ");
13 |     scanf("%d",&p.at);
14 |     printf("Enter Burst Time: ");
15 |     scanf("%d",&p.bt);
16 |     p.rt=p.bt;
17 |     return p;
18 | }
19 | int main()
20 | {
21 |     struct proc p[10],temp;
22 |     float avgtat=0,avgwt=0;
23 |     int n,s,remain=0,time;
24 |     printf("<--SRTF Scheduling Algorithm (Preemptive)-->\n");
25 |     printf("Enter Number of Processes: ");
26 |     scanf("%d",&n);
27 |     for(int i=0;i<n;i++)
28 |         p[i]=read(i+1);
29 |     for(int i=0;i<n-1;i++)
30 |         for(int j=0;j<n-i-1;j++)    
31 |             if(p[j].at>p[j+1].at)
32 |             {
33 |             temp=p[j];
34 |             p[j]=p[j+1];
35 |             p[j+1]=temp;
36 |             }
37 |     printf("\nProcess\t\tAT\tBT\tCT\tTAT\tWT\n");
38 |     p[9].rt=MAX;
39 |     for(time=0;remain!=n;time++)
40 |     {
41 |         s=9;
42 |         for(int i=0;i<n;i++)
43 |             if(p[i].at<=time&&p[i].rt<p[s].rt&&p[i].rt>0)
44 |                 s=i;
45 |         p[s].rt--;
46 |         if(p[s].rt==0)
47 |         {
48 |             remain++;
49 |             p[s].ct=time+1;
50 |             p[s].tat=p[s].ct-p[s].at;
51 |             avgtat+=p[s].tat;
52 |             p[s].wt=p[s].tat-p[s].bt;
53 |             avgwt+=p[s].wt;
54 |             printf("P%d\t\t%d\t%d\t%d\t%d\t%d\n",p[s].no,p[s].at,p[s].bt,p[s].ct,p[s].tat,p[s].wt);
55 |         }
56 |     }
57 |     avgtat/=n,avgwt/=n;
58 |     printf("\nAverage TurnAroundTime=%f\nAverage WaitingTime=%f",avgtat,avgwt);
59 | }
60 | 


--------------------------------------------------------------------------------
/Non-Preemptive Priority Scheduling (Highest Priority First) Algorithm.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #define MIN -9999;
 3 | struct proc
 4 | {
 5 |     int no,at,bt,ct,wt,tat,pri,status;
 6 | };
 7 | struct proc read(int i)
 8 | {
 9 |     struct proc p;
10 |     printf("\nProcess No: %d\n",i);
11 |     p.no=i;
12 |     printf("Enter Arrival Time: ");
13 |     scanf("%d",&p.at);
14 |     printf("Enter Burst Time: ");
15 |     scanf("%d",&p.bt);
16 |     printf("Enter Priority: ");
17 |     scanf("%d",&p.pri);
18 |     p.status=0;
19 |     return p;
20 | }
21 | 
22 | void main()
23 | {
24 |     int n,l,ct=0,remaining;
25 |     struct proc p[10],temp;
26 |     float avgtat=0,avgwt=0;
27 |     printf("<--Highest Priority First Scheduling Algorithm (Non-Preemptive)-->\n");
28 |     printf("Enter Number of Processes: ");
29 |     scanf("%d",&n);
30 |     for(int i=0;i<n;i++)
31 |         p[i]=read(i+1);
32 |     for(int i=0;i<n-1;i++)
33 |         for(int j=0;j<n-i-1;j++)    
34 |             if(p[j].at>p[j+1].at)
35 |             {
36 |             temp=p[j];
37 |             p[j]=p[j+1];
38 |             p[j+1]=temp;
39 |             }
40 |     p[9].pri=MIN;
41 |     remaining=n;
42 |     printf("\nProcessNo\tAT\tBT\tPri\tCT\tTAT\tWT\tRT\n");
43 |     for(ct=p[0].at;remaining!=0;)
44 |     {
45 |         l=9;
46 |         for(int i=0;i<n;i++)
47 |             if(p[i].at<=ct && p[i].status!=1 && p[i].pri>p[l].pri)
48 |                 l=i;
49 |         p[l].ct=ct=ct+p[l].bt;
50 |         p[l].tat=p[l].ct-p[l].at;
51 |         avgtat+=p[l].tat;
52 |         p[l].wt=p[l].tat-p[l].bt;
53 |         avgwt+=p[l].wt;
54 |         p[l].status=1;
55 |         remaining--;
56 |         printf("P%d\t\t%d\t%d\t%d\t%d\t%d\t%d\t%d\n",p[l].no,p[l].at,p[l].bt,p[l].pri,p[l].ct,p[l].tat,p[l].wt,p[l].wt);
57 |     }
58 |     avgtat/=n,avgwt/=n;
59 |     printf("\nAverage TurnAroundTime=%f\nAverage WaitingTime=%f",avgtat,avgwt);
60 | }


--------------------------------------------------------------------------------
/Non-Preemptive Priority Scheduling (Smallest Priority First) Algorithm.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #define MAX 9999;
 3 | struct proc
 4 | {
 5 |     int no,at,bt,ct,wt,tat,pri,status;
 6 | };
 7 | struct proc read(int i)
 8 | {
 9 |     struct proc p;
10 |     printf("\nProcess No: %d\n",i);
11 |     p.no=i;
12 |     printf("Enter Arrival Time: ");
13 |     scanf("%d",&p.at);
14 |     printf("Enter Burst Time: ");
15 |     scanf("%d",&p.bt);
16 |     printf("Enter Priority: ");
17 |     scanf("%d",&p.pri);
18 |     p.status=0;
19 |     return p;
20 | }
21 | 
22 | void main()
23 | {
24 |     int n,s,ct=0,remaining;
25 |     struct proc p[10],temp;
26 |     float avgtat=0,avgwt=0;
27 |     printf("<--Smallest Priority First Scheduling Algorithm (Non-Preemptive)-->\n");
28 |     printf("Enter Number of Processes: ");
29 |     scanf("%d",&n);
30 |     for(int i=0;i<n;i++)
31 |         p[i]=read(i+1);
32 |     for(int i=0;i<n-1;i++)
33 |         for(int j=0;j<n-i-1;j++)    
34 |             if(p[j].at>p[j+1].at)
35 |             {
36 |             temp=p[j];
37 |             p[j]=p[j+1];
38 |             p[j+1]=temp;
39 |             }
40 |     p[9].pri=MAX;
41 |     remaining=n;
42 |     printf("\nProcessNo\tAT\tBT\tPri\tCT\tTAT\tWT\tRT\n");
43 |     for(ct=p[0].at;remaining!=0;)
44 |     {
45 |         s=9;
46 |         for(int i=0;i<n;i++)
47 |             if(p[i].at<=ct && p[i].status!=1 && p[i].pri<p[s].pri)
48 |                 s=i;
49 |         p[s].ct=ct=ct+p[s].bt;
50 |         p[s].tat=p[s].ct-p[s].at;
51 |         avgtat+=p[s].tat;
52 |         p[s].wt=p[s].tat-p[s].bt;
53 |         avgwt+=p[s].wt;
54 |         p[s].status=1;
55 |         remaining--;
56 |         printf("P%d\t\t%d\t%d\t%d\t%d\t%d\t%d\t%d\n",p[s].no,p[s].at,p[s].bt,p[s].pri,p[s].ct,p[s].tat,p[s].wt,p[s].wt);
57 |     }
58 |     avgtat/=n,avgwt/=n;
59 |     printf("\nAverage TurnAroundTime=%f\nAverage WaitingTime=%f",avgtat,avgwt);
60 | }


--------------------------------------------------------------------------------
/Round Robin Scheduling Algorithm.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | struct proc
 3 | {
 4 |     int no,at,bt,ct,tat,wt,rt;
 5 | };
 6 | struct proc read(int i)
 7 | {
 8 |     struct proc p;
 9 |     printf("\nProcess No: %d\n",i);
10 |     p.no=i;
11 |     printf("Enter Arrival Time: ");
12 |     scanf("%d",&p.at);
13 |     printf("Enter Burst Time: ");
14 |     scanf("%d",&p.bt);
15 |     p.rt=p.bt;
16 |     return p;
17 | }
18 | int main()
19 | {
20 |     struct proc p[10],tmp;
21 |     float avgtat=0,avgwt=0;
22 |     int n,tq,ct=0,flag=0,remaining;
23 |     printf("<--Round Robin Scheduling Algorithm-->\n");
24 |     printf("Enter Number of Processes: ");
25 |     scanf("%d",&n);
26 |     printf("Enter Time Quantum: ");
27 |     scanf("%d",&tq);
28 |     for(int i=0;i<n;i++)
29 |         p[i]=read(i+1);
30 |     for(int i=0;i<n-1;i++)
31 |         for(int j=0;j<n-i-1;j++)    
32 |             if(p[j].at>p[j+1].at)
33 |             {
34 |             tmp=p[j];
35 |             p[j]=p[j+1];
36 |             p[j+1]=tmp;
37 |             }
38 | 	remaining=n; 
39 |     printf("\nProcessNo\tAT\tBT\tCT\tTAT\tWT\n");
40 |     for(int i=0;remaining!=0;)
41 |     {
42 |         if(p[i].rt<=tq&&p[i].rt>0)
43 |         {
44 | 			ct+=p[i].rt;
45 | 			p[i].rt=0;
46 | 			flag=1;
47 |         }
48 |         else if(p[i].rt>0)
49 |         {
50 | 			p[i].rt-=tq;
51 | 			ct+=tq;
52 |         }
53 |         if(p[i].rt==0&&flag==1)
54 |         {
55 | 			flag = 0;
56 | 			remaining--;
57 | 			p[i].ct=ct;
58 | 			p[i].tat=p[i].ct-p[i].at;
59 | 			avgtat+=p[i].tat;
60 |             p[i].wt=p[i].tat-p[i].bt;
61 |             avgwt+=p[i].wt;
62 | 			printf("P%d\t\t%d\t%d\t%d\t%d\t%d\n",p[i].no,p[i].at,p[i].bt,p[i].ct,p[i].tat,p[i].wt);
63 |         }
64 |         if(i!=n-1&&p[i+1].at<=ct)
65 | 			i++;
66 |         else
67 | 			i=0;
68 |     }
69 |     avgtat/=n,avgwt/=n;
70 |     printf("\nAverage TurnAroundTime=%f\nAverage WaitingTime=%f",avgtat,avgwt);
71 | }


--------------------------------------------------------------------------------
/Highest Response Ratio Next (HRRN) Scheduling Algorithm.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #define MIN -9999
 3 | struct proc
 4 | {
 5 |     int no,at,bt,ct,tat,wt,completed;
 6 | };
 7 | struct proc read(int i)
 8 | {
 9 |     struct proc p;
10 |     printf("\nProcess No: %d\n",i);
11 |     p.no=i;
12 |     printf("Enter Arrival Time: ");
13 |     scanf("%d",&p.at);
14 |     printf("Enter Burst Time: ");
15 |     scanf("%d",&p.bt);
16 |     p.completed=0;
17 |     return p;
18 | }
19 | void main()
20 | {
21 |     int n,l,t,remaining;
22 |     float hrr,temp,avgtat=0,avgwt=0;
23 |     struct proc p[10],tmp;
24 |     printf("<--Highest Response Ratio Next Scheduling Algorithm (Non-Preemptive)-->\n");
25 |     printf("Enter Number of Processes: ");
26 |     scanf("%d",&n);
27 |     for(int i=0;i<n;i++)
28 |         p[i]=read(i+1);
29 |     for(int i=0;i<n-1;i++)
30 |         for(int j=0;j<n-i-1;j++)    
31 |             if(p[j].at>p[j+1].at)
32 |             {
33 |             tmp=p[j];
34 |             p[j]=p[j+1];
35 |             p[j+1]=tmp;
36 |             }
37 |     remaining=n;
38 |     printf("\n\nProcess\t\tAT\tBT\tCT\tTAT\tWT\n");
39 |     for (t=p[0].at;remaining!=0;) 
40 |     {
41 |         hrr=MIN;
42 |         for (int i=0;i<n;i++) 
43 |             if (p[i].at<=t&&p[i].completed!=1) 
44 |             {
45 |                 temp=(p[i].bt+(t-p[i].at))/p[i].bt;
46 |                 if (hrr<temp) 
47 |                     hrr=temp,l=i;
48 |             }
49 |         t+=p[l].bt;
50 |         p[l].ct=t;
51 |         p[l].tat=p[l].ct-p[l].at;
52 |         p[l].wt=p[l].tat-p[l].bt;
53 |         p[l].completed = 1;
54 |         remaining--;
55 |     }
56 |     for(int i=0;i<n;i++)
57 |     {
58 |         avgtat+=p[i].tat,avgwt+=p[i].wt;
59 |         printf("P%d\t\t%d\t%d\t%d\t%d\t%d\n",p[i].no,p[i].at,p[i].bt,p[i].ct,p[i].tat,p[i].wt);
60 |     }
61 |     avgtat/=n,avgwt/=n;
62 |     printf("\nAverage TurnAroundTime=%f\nAverage WaitingTime=%f",avgtat,avgwt);
63 | }
64 | 


--------------------------------------------------------------------------------
/SJF Scheduling Algorithm.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | struct proc
 3 | {
 4 |     int no,at,bt,it,ct,tat,wt;
 5 | };
 6 | struct proc read(int i)
 7 | {
 8 |     struct proc p;
 9 |     printf("\nProcess No: %d\n",i);
10 |     p.no=i;
11 |     printf("Enter Arrival Time: ");
12 |     scanf("%d",&p.at);
13 |     printf("Enter Burst Time: ");
14 |     scanf("%d",&p.bt);
15 |     return p;
16 | }
17 | int main()
18 | {
19 |     int  n,j,min=0;
20 |     float avgtat=0,avgwt=0;
21 |     struct proc p[10],temp;
22 |     printf("<--SJF Scheduling Algorithm (Non-Preemptive)-->\n");
23 |     printf("Enter Number of Processes: ");
24 |     scanf("%d",&n);
25 |     for(int i=0;i<n;i++)
26 |         p[i]=read(i+1);
27 |     for(int i=0;i<n-1;i++)
28 |         for(j=0;j<n-i-1;j++)    
29 |             if(p[j].at>p[j+1].at)
30 |             {
31 |             temp=p[j];
32 |             p[j]=p[j+1];
33 |             p[j+1]=temp;
34 |             }
35 |     for(j=1;j<n&&p[j].at==p[0].at;j++)
36 |         if(p[j].bt<p[min].bt)
37 |             min=j;
38 |     temp=p[0];
39 |     p[0]=p[min];
40 |     p[min]=temp;
41 |     p[0].it=p[0].at;
42 |     p[0].ct=p[0].it+p[0].bt;
43 |     for(int i=1;i<n;i++)
44 |     {
45 |         for(j=i+1,min=i;j<n&&p[j].at<=p[i-1].ct;j++)
46 |             if(p[j].bt<p[min].bt)
47 |                 min=j;
48 |         temp=p[i];
49 |         p[i]=p[min];
50 |         p[min]=temp;
51 |         if(p[i].at<=p[i-1].ct)
52 |             p[i].it=p[i-1].ct;
53 |         else
54 |             p[i].it=p[i].at;
55 |         p[i].ct=p[i].it+p[i].bt;
56 |     }
57 |     printf("\nProcess\t\tAT\tBT\tCT\tTAT\tWT\tRT\n");
58 |     for(int i=0;i<n;i++)
59 |     {
60 |         p[i].tat=p[i].ct-p[i].at;
61 |         avgtat+=p[i].tat;
62 |         p[i].wt=p[i].tat-p[i].bt;
63 |         avgwt+=p[i].wt;
64 |         printf("P%d\t\t%d\t%d\t%d\t%d\t%d\t%d\n",p[i].no,p[i].at,p[i].bt,p[i].ct,p[i].tat,p[i].wt,p[i].wt);
65 |     }
66 |     avgtat/=n,avgwt/=n;
67 |     printf("\nAverage TurnAroundTime=%f\nAverage WaitingTime=%f",avgtat,avgwt);
68 | }


--------------------------------------------------------------------------------
/Preemptive Priority Scheduling (Highest Priority First) Algorithm.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #define MIN -9999;
 3 | struct proc
 4 | {
 5 |     int no,at,bt,rt,ct,wt,tat,pri,temp;
 6 | };
 7 | struct proc read(int i)
 8 | {
 9 |     struct proc p;
10 |     printf("\nProcess No: %d\n",i);
11 |     p.no=i;
12 |     printf("Enter Arrival Time: ");
13 |     scanf("%d",&p.at);
14 |     printf("Enter Burst Time: ");
15 |     scanf("%d",&p.bt);
16 |     p.rt=p.bt;
17 |     printf("Enter Priority: ");
18 |     scanf("%d",&p.pri);
19 |     p.temp=p.pri;
20 |     return p;
21 | }
22 | void main()
23 | {
24 |     int i,n,c,remaining,max_val,max_index;
25 |     struct proc p[10],temp;
26 |     float avgtat=0,avgwt=0;
27 |     printf("<--Highest Priority First Scheduling Algorithm (Preemptive)-->\n");
28 |     printf("Enter Number of Processes: ");
29 |     scanf("%d",&n);
30 |     for(int i=0;i<n;i++)
31 |         p[i]=read(i+1);
32 |     remaining=n;
33 | 	for(int i=0;i<n-1;i++)
34 |         for(int j=0;j<n-i-1;j++)    
35 |             if(p[j].at>p[j+1].at)
36 |             {
37 |             temp=p[j];
38 |             p[j]=p[j+1];
39 |             p[j+1]=temp;
40 |             }
41 |     max_val=p[0].temp,max_index=0;
42 | 	for(int j=0;j<n&&p[j].at<=p[0].at;j++)
43 | 		if(p[j].temp>max_val)
44 | 			max_val=p[j].temp,max_index=j;
45 | 	i=max_index;
46 | 	c=p[i].ct=p[i].at+1;
47 | 	p[i].rt--;
48 | 	if(p[i].rt==0)
49 | 	{
50 | 		p[i].temp=MIN;
51 | 		remaining--;
52 | 	}
53 | 	while(remaining>0)
54 | 	{
55 | 		max_val=p[0].temp,max_index=0;
56 |     	for(int j=0;j<n&&p[j].at<=c;j++)
57 |     		if(p[j].temp>max_val)
58 |     			max_val=p[j].temp,max_index=j;
59 |     	i=max_index;
60 | 		p[i].ct=c=c+1;
61 | 		p[i].rt--;
62 | 		if(p[i].rt==0)
63 | 		{
64 | 		    p[i].temp=MIN;
65 | 		    remaining--;
66 | 		}
67 | 	}
68 | 	printf("\nProcessNo\tAT\tBT\tPri\tCT\tTAT\tWT\n");
69 |     for(int i=0;i<n;i++)
70 |     {
71 |         p[i].tat=p[i].ct-p[i].at;
72 |         avgtat+=p[i].tat;
73 |         p[i].wt=p[i].tat-p[i].bt;
74 |         avgwt+=p[i].wt;
75 |         printf("P%d\t\t%d\t%d\t%d\t%d\t%d\t%d\n",p[i].no,p[i].at,p[i].bt,p[i].pri,p[i].ct,p[i].tat,p[i].wt);
76 |     }
77 |     avgtat/=n,avgwt/=n;
78 |     printf("\nAverage TurnAroundTime=%f\nAverage WaitingTime=%f",avgtat,avgwt);
79 | }


--------------------------------------------------------------------------------
/Preemptive Priority Scheduling (Smallest Priority First) Algorithm.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #define MAX 9999;
 3 | struct proc
 4 | {
 5 |     int no,at,bt,rt,ct,wt,tat,pri,temp;
 6 | };
 7 | struct proc read(int i)
 8 | {
 9 |     struct proc p;
10 |     printf("\nProcess No: %d\n",i);
11 |     p.no=i;
12 |     printf("Enter Arrival Time: ");
13 |     scanf("%d",&p.at);
14 |     printf("Enter Burst Time: ");
15 |     scanf("%d",&p.bt);
16 |     p.rt=p.bt;
17 |     printf("Enter Priority: ");
18 |     scanf("%d",&p.pri);
19 |     p.temp=p.pri;
20 |     return p;
21 | }
22 | void main()
23 | {
24 |     int i,n,c,remaining,min_val,min_index;
25 |     struct proc p[10],temp;
26 |     float avgtat=0,avgwt=0;
27 |     printf("<--Smallest Priority First Scheduling Algorithm (Preemptive)-->\n");
28 |     printf("Enter Number of Processes: ");
29 |     scanf("%d",&n);
30 |     for(int i=0;i<n;i++)
31 |         p[i]=read(i+1);
32 |     remaining=n;
33 | 	for(int i=0;i<n-1;i++)
34 |         for(int j=0;j<n-i-1;j++)    
35 |             if(p[j].at>p[j+1].at)
36 |             {
37 |             temp=p[j];
38 |             p[j]=p[j+1];
39 |             p[j+1]=temp;
40 |             }
41 |     min_val=p[0].temp,min_index=0;
42 | 	for(int j=0;j<n&&p[j].at<=p[0].at;j++)
43 | 		if(p[j].temp<min_val)
44 | 			min_val=p[j].temp,min_index=j;
45 | 	i=min_index;
46 | 	c=p[i].ct=p[i].at+1;
47 | 	p[i].rt--;
48 | 	if(p[i].rt==0)
49 | 	{
50 | 		p[i].temp=MAX;
51 | 		remaining--;
52 | 	}
53 | 	while(remaining>0)
54 | 	{
55 | 		min_val=p[0].temp,min_index=0;
56 |     	for(int j=0;j<n&&p[j].at<=c;j++)
57 |     		if(p[j].temp<min_val)
58 |     			min_val=p[j].temp,min_index=j;
59 |     	i=min_index;
60 | 		p[i].ct=c=c+1;
61 | 		p[i].rt--;
62 | 		if(p[i].rt==0)
63 | 		{
64 | 		    p[i].temp=MAX;
65 | 		    remaining--;
66 | 		}
67 | 	}
68 | 		printf("\nProcessNo\tAT\tBT\tPri\tCT\tTAT\tWT\n");
69 |     for(int i=0;i<n;i++)
70 |     {
71 |         p[i].tat=p[i].ct-p[i].at;
72 |         avgtat+=p[i].tat;
73 |         p[i].wt=p[i].tat-p[i].bt;
74 |         avgwt+=p[i].wt;
75 |         printf("P%d\t\t%d\t%d\t%d\t%d\t%d\t%d\n",p[i].no,p[i].at,p[i].bt,p[i].pri,p[i].ct,p[i].tat,p[i].wt);
76 |     }
77 |     avgtat/=n,avgwt/=n;
78 |     printf("\nAverage TurnAroundTime=%f\nAverage WaitingTime=%f",avgtat,avgwt);
79 | }


--------------------------------------------------------------------------------
/Round Robin (Queue Implementation) Scheduling Algorithm.c:
--------------------------------------------------------------------------------
  1 | #include<stdio.h>
  2 | int n,q[10],front=-1,rear=-1;
  3 | struct proc
  4 | {
  5 |     int no,at,bt,ct,tat,wt,rt,completed;
  6 | };
  7 | void enqueue(int i)
  8 | {
  9 |     if(rear==10)
 10 |         printf("Overflow");
 11 |     rear++;
 12 |     q[rear]=i;
 13 |     if(front==-1)
 14 |         front=0;
 15 | }
 16 | int dequeue()
 17 | {
 18 |     if(front==-1)
 19 |         printf("Underflow");
 20 |     int temp=q[front];
 21 |     if(front==rear)
 22 |         front=rear=-1;
 23 |     else
 24 |         front++;
 25 |     return temp;
 26 | }
 27 | int isInQueue(int i)
 28 | {
 29 |     int k;
 30 |     for(k=front;k<=rear;k++)
 31 |     {
 32 |         if(q[k]==i)
 33 |             return 1;
 34 |     }
 35 |     return 0;
 36 | }
 37 | struct proc read(int i)
 38 | {
 39 |     struct proc p;
 40 |     printf("\nProcess No: %d\n",i);
 41 |     p.no=i;
 42 |     printf("Enter Arrival Time: ");
 43 |     scanf("%d",&p.at);
 44 |     printf("Enter Burst Time: ");
 45 |     scanf("%d",&p.bt);
 46 |     p.rt=p.bt;
 47 |     p.completed=0;
 48 |     return p;
 49 | }
 50 | void main()
 51 | {
 52 |     int i,j,tq,time=0,remaining;
 53 |     float avgtat=0,avgwt=0;
 54 |     struct proc p[10],temp;
 55 |     printf("<--Round Robin (Queue Implementation) Scheduling Algorithm-->\n");
 56 |     printf("Enter Number of Processes: ");
 57 |     scanf("%d",&n);
 58 |     printf("Enter Time Quantum: ");
 59 |     scanf("%d",&tq);
 60 |     for(int i=0;i<n;i++)
 61 |         p[i]=read(i+1);
 62 |     for(int i=0;i<n-1;i++)
 63 |         for(j=0;j<n-i-1;j++)    
 64 |             if(p[j].at>p[j+1].at)
 65 |             {
 66 |             temp=p[j];
 67 |             p[j]=p[j+1];
 68 |             p[j+1]=temp;
 69 |             }
 70 |     remaining=n;
 71 |     enqueue(0);
 72 |     printf("\nQueue: ");
 73 |     for(time=p[0].at;remaining!=0;)
 74 |     {   
 75 |         i=dequeue();
 76 |         if(p[i].rt<=tq)
 77 |         {
 78 |             time+=p[i].rt;
 79 |             p[i].rt=0;
 80 |             p[i].completed=1;
 81 |             remaining--;
 82 |             printf("-> P%d",p[i].no);
 83 |             p[i].ct=time;
 84 |             p[i].tat=p[i].ct-p[i].at;
 85 |             avgtat+=p[i].tat;
 86 |             p[i].wt=p[i].tat-p[i].bt;
 87 |             avgwt+=p[i].wt;
 88 |             for(j=0;j<n;j++)
 89 |                 if(p[j].at<=time && p[j].completed!=1&& isInQueue(j)!=1)
 90 |                     enqueue(j);
 91 |         }
 92 |         else
 93 |         {
 94 |             time+=tq;
 95 |             p[i].rt-=tq;
 96 |             printf("-> P%d",p[i].no);
 97 |             for(j=0;j<n;j++)
 98 |                 if(p[j].at<=time && p[j].completed!=1&&i!=j&& isInQueue(j)!=1)
 99 |                     enqueue(j);
100 |             enqueue(i);
101 |         }
102 |     }
103 |     printf("\n\nProcess\t\tAT\tBT\tCT\tTAT\tWT\n");
104 |     for(i=0;i<n;i++)
105 |         printf("P%d\t\t%d\t%d\t%d\t%d\t%d\n",p[i].no,p[i].at,p[i].bt,p[i].ct,p[i].tat,p[i].wt);
106 |     avgtat/=n,avgwt/=n;
107 |     printf("\nAverage TurnAroundTime=%f\nAverage WaitingTime=%f",avgtat,avgwt);
108 | }
109 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # [Scheduling Algorithms](https://github.com/PrakharPipersania/Scheduling-Algorithms)
 2 | 
 3 | ![Language](https://img.shields.io/badge/Language-C-255fcc.svg)&nbsp;
 4 | [![License](https://img.shields.io/badge/License-MIT-orange.svg)](./LICENSE)&nbsp;
 5 | ![Total Tests](https://img.shields.io/badge/Total%20Tests-58%20(All%20Passed)-purple.svg)&nbsp;
 6 | ![Progress](https://img.shields.io/badge/Progress-100%25-brightgreen.svg)&nbsp;
 7 | 
 8 | ## Some Popular Process Scheduling Algorithms are:-
 9 | * First Come First Served (FCFS) Scheduling
10 | * Shortest Job First (SJN) Scheduling
11 | * Priority Scheduling
12 | * Round Robin(RR) Scheduling
13 | * Highest Response Ratio Next(HRRN) Scheduling
14 | 
15 | ### First Come First Served Scheduling:
16 | In this Algorithm, Process that request CPU first, CPU is allocated first to that process .i.e. the algorithm is known as first come, first served. It based on FIFO (First in First Out) queue data structure. When a process entered in the ready queue, its Process Control Block (PCB) is added to end of the Queue. When CPU gets free after a process execution, a new process from the head of the queue is removed and enters in running state.
17 | * Criteria: Arrival Time
18 | * Mode: Non-Preemptive
19 | * Convoy Effect OR Starvation (When the process with the highest burst time is first entertained by the CPU)
20 | 
21 | ### Shortest Job First Scheduling:
22 | SJF is a preemptive and Non-Preemptive algorithm. It based on length of latter’s next CPU burst. If a process acquired CPU and execution is going on, a new process with small CPU burst entered. Then CPU is preempted from current process and will give to further process. If two processes have the same length next CPU burst, FCFS scheduling is used to break the tie. Shortest Next CPUburst is also an appropriate term for SJF algorithm because scheduler examines the length of next CPU burst continuously.
23 | * Criteria: Burst Time
24 | * Mode(Shortest Job First): Non-Preemptive
25 | * Mode(Shortest Remaining Time First ): Preemptive
26 | 
27 | ### Priority Scheduling:
28 | SJF is a simple priority algorithm, where we are not considering the smallest next CPU burst, scheduler consider the priority of processes. The priority assigned to each process and CPU allocated to highest priority process. Equal priority processes scheduled in FCFS order. Priority can be discussed regarding Lower and higher priority.Numbers denote it.We can use 0 for lower priority as well as more top priority.There is not a hard and fast rule to assign numbers to preferences.
29 | * Criteria: Priority
30 | * Mode: Non-Preemptive OR Preemptive
31 | 
32 | ### Round Robin Scheduling
33 | Round Robin Scheduling algorithm designed for time-sharing systems. It is similar to FCFS scheduling but adding preemption to switch the processes after a small unit of time. A small unit of time is called a time quantum. A time quantum might be from 10 to 100 millisecond.
34 | * How RR algorithm works:  Ready queue as a FIFO queue. The new process will add to the tail of the ready queue and process is removed from the head of queue.CPU select a process from ready queue, set a timer. After completion of time quantum, the process will be preempted doesn’t matter it is completed or not. IF the process not finished it will add in the tail of the queue and CPU select new process. In this way, the process is going on.
35 | * Criteria: Time Quantum
36 | * Mode: Preemptive
37 | * No Starvation
38 | 
39 | ### Highest Response Ratio Next Scheduling
40 | Highest Response Ratio Next (HRNN) is one of the most optimal scheduling algorithms. This is a non-preemptive algorithm in which, the scheduling is done on the basis of an extra parameter called Response Ratio. A Response Ratio is calculated for each of the available jobs and the Job with the highest response ratio is given priority over the others.
41 | * Criteria: Response Ratio
42 | * Mode: Non-Preemptive
43 | 


--------------------------------------------------------------------------------