Fix

Author: Hardvan

src/main/java/com/thealgorithms/scheduling/NonPreemptivePriorityScheduling.java

@@ -14,23 +14,26 @@ private NonPreemptivePriorityScheduling() {
     }
 
     /**
-     * Represents a process with an ID, burst time, priority, and start time.
+     * Represents a process with an ID, burst time, priority, arrival time, and start time.
      */
     static class Process implements Comparable<Process> {
         int id;
+        int arrivalTime;
         int startTime;
         int burstTime;
         int priority;
 
         /**
          * Constructs a Process instance with the specified parameters.
          *
-         * @param id        Unique identifier for the process
-         * @param burstTime Time required for the process execution
-         * @param priority  Priority of the process
+         * @param id          Unique identifier for the process
+         * @param arrivalTime Time when the process arrives in the system
+         * @param burstTime   Time required for the process execution
+         * @param priority    Priority of the process
          */
-        Process(int id, int burstTime, int priority) {
+        Process(int id, int arrivalTime, int burstTime, int priority) {
             this.id = id;
+            this.arrivalTime = arrivalTime;
             this.startTime = -1;
             this.burstTime = burstTime;
             this.priority = priority;
@@ -39,35 +42,44 @@ static class Process implements Comparable<Process> {
         /**
          * Compare based on priority for scheduling. The process with the lowest
          * priority is selected first.
+         * If two processes have the same priority, the one that arrives earlier is selected.
          *
          * @param other The other process to compare against
          * @return A negative integer, zero, or a positive integer as this process
          *         is less than, equal to, or greater than the specified process.
          */
         @Override
         public int compareTo(Process other) {
+            if (this.priority == other.priority) {
+                return Integer.compare(this.arrivalTime, other.arrivalTime);
+            }
             return Integer.compare(this.priority, other.priority);
         }
     }
 
     /**
-     * Schedules processes based on their priority in a non-preemptive manner.
+     * Schedules processes based on their priority in a non-preemptive manner, considering their arrival times.
      *
      * @param processes Array of processes to be scheduled.
      * @return Array of processes in the order they are executed.
      */
     public static Process[] scheduleProcesses(Process[] processes) {
         PriorityQueue<Process> pq = new PriorityQueue<>();
+        int currentTime = 0;
+        int index = 0;
+        Process[] executionOrder = new Process[processes.length];
+
         for (Process process : processes) {
             pq.add(process);
         }
 
-        Process[] executionOrder = new Process[processes.length];
-        int index = 0;
-        int currentTime = 0;
-
         while (!pq.isEmpty()) {
             Process currentProcess = pq.poll();
+
+            if (currentTime < currentProcess.arrivalTime) {
+                currentTime = currentProcess.arrivalTime;
+            }
+
             currentProcess.startTime = currentTime;
             executionOrder[index++] = currentProcess;
             currentTime += currentProcess.burstTime;
@@ -85,11 +97,10 @@ public static Process[] scheduleProcesses(Process[] processes) {
      */
     public static double calculateAverageWaitingTime(Process[] processes, Process[] executionOrder) {
         int totalWaitingTime = 0;
-        int currentTime = 0;
 
         for (Process process : executionOrder) {
-            totalWaitingTime += currentTime;
-            currentTime += process.burstTime;
+            int waitingTime = process.startTime - process.arrivalTime;
+            totalWaitingTime += waitingTime;
         }
 
         return (double) totalWaitingTime / processes.length;
@@ -104,11 +115,10 @@ public static double calculateAverageWaitingTime(Process[] processes, Process[]
      */
     public static double calculateAverageTurnaroundTime(Process[] processes, Process[] executionOrder) {
         int totalTurnaroundTime = 0;
-        int currentTime = 0;
 
         for (Process process : executionOrder) {
-            currentTime += process.burstTime;
-            totalTurnaroundTime += currentTime;
+            int turnaroundTime = (process.startTime + process.burstTime) - process.arrivalTime;
+            totalTurnaroundTime += turnaroundTime;
         }
 
         return (double) totalTurnaroundTime / processes.length;

src/test/java/com/thealgorithms/scheduling/NonPreemptivePrioritySchedulingTest.java

@@ -1,42 +1,53 @@
 package com.thealgorithms.scheduling;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertNotEquals;
 
 import org.junit.jupiter.api.Test;
 
 public class NonPreemptivePrioritySchedulingTest {
 
     @Test
     public void testCalculateAverageWaitingTime() {
-        NonPreemptivePriorityScheduling.Process[] processes = {new NonPreemptivePriorityScheduling.Process(1, 10, 2), new NonPreemptivePriorityScheduling.Process(2, 5, 1), new NonPreemptivePriorityScheduling.Process(3, 8, 3)};
+        NonPreemptivePriorityScheduling.Process[] processes = {
+            new NonPreemptivePriorityScheduling.Process(1, 0, 10, 2), // id, arrivalTime, burstTime, priority
+            new NonPreemptivePriorityScheduling.Process(2, 0, 5, 1),
+            new NonPreemptivePriorityScheduling.Process(3, 0, 8, 3)
+        };
         NonPreemptivePriorityScheduling.Process[] executionOrder = NonPreemptivePriorityScheduling.scheduleProcesses(processes);
 
-        double expectedAvgWaitingTime = 6.666666666666667; // (0 + 10 + 5) / 3
+        double expectedAvgWaitingTime = (0 + 5 + 15) / 3.0; // Waiting times: 0 for P2, 5 for P1, 15 for P3
         double actualAvgWaitingTime = NonPreemptivePriorityScheduling.calculateAverageWaitingTime(processes, executionOrder);
 
         assertEquals(expectedAvgWaitingTime, actualAvgWaitingTime, 0.01, "Average waiting time should be calculated correctly.");
     }
 
     @Test
     public void testCalculateAverageTurnaroundTime() {
-        NonPreemptivePriorityScheduling.Process[] processes = {new NonPreemptivePriorityScheduling.Process(1, 10, 2), new NonPreemptivePriorityScheduling.Process(2, 5, 1), new NonPreemptivePriorityScheduling.Process(3, 8, 3)};
+        NonPreemptivePriorityScheduling.Process[] processes = {
+            new NonPreemptivePriorityScheduling.Process(1, 0, 10, 2), // id, arrivalTime, burstTime, priority
+            new NonPreemptivePriorityScheduling.Process(2, 0, 5, 1),
+            new NonPreemptivePriorityScheduling.Process(3, 0, 8, 3)
+        };
         NonPreemptivePriorityScheduling.Process[] executionOrder = NonPreemptivePriorityScheduling.scheduleProcesses(processes);
 
-        double expectedAvgTurnaroundTime = (5 + 15 + 23) / 3.0; // (5 + (5 + 10) + (5 + 10 + 8)) / 3
+        double expectedAvgTurnaroundTime = (5 + 15 + 23) / 3.0; // Turnaround times: 5 for P2, 15 for P1, 23 for P3
         double actualAvgTurnaroundTime = NonPreemptivePriorityScheduling.calculateAverageTurnaroundTime(processes, executionOrder);
 
         assertEquals(expectedAvgTurnaroundTime, actualAvgTurnaroundTime, 0.01, "Average turnaround time should be calculated correctly.");
     }
 
     @Test
     public void testStartTimeIsCorrect() {
-        NonPreemptivePriorityScheduling.Process[] processes = {new NonPreemptivePriorityScheduling.Process(1, 10, 2), new NonPreemptivePriorityScheduling.Process(2, 5, 1), new NonPreemptivePriorityScheduling.Process(3, 8, 3)};
+        NonPreemptivePriorityScheduling.Process[] processes = {
+            new NonPreemptivePriorityScheduling.Process(1, 0, 10, 2), // id, arrivalTime, burstTime, priority
+            new NonPreemptivePriorityScheduling.Process(2, 0, 5, 1),
+            new NonPreemptivePriorityScheduling.Process(3, 0, 8, 3)
+        };
         NonPreemptivePriorityScheduling.Process[] executionOrder = NonPreemptivePriorityScheduling.scheduleProcesses(processes);
 
         // Check that the start time for each process is correctly set
-        assertEquals(0, executionOrder[0].startTime, "First process should start at time 0.");
-        assertEquals(5, executionOrder[1].startTime, "Second process should start after the first process.");
-        assertEquals(15, executionOrder[2].startTime, "Third process should start after the second process.");
+        assertEquals(0, executionOrder[0].startTime, "First process (P2) should start at time 0."); // Process 2 has the highest priority
+        assertEquals(5, executionOrder[1].startTime, "Second process (P1) should start at time 5.");
+        assertEquals(15, executionOrder[2].startTime, "Third process (P3) should start at time 15.");
     }
 }