Refactor ProcessDetails and PreemptivePriorityScheduling for consistency

Author: doxxx93

src/main/java/com/thealgorithms/devutils/entities/ProcessDetails.java

@@ -6,6 +6,14 @@ public class ProcessDetails {
     private int burstTime;
     private int waitingTime;
     private int turnAroundTime;
+    private int priority;
+
+    public ProcessDetails(final String processId, final int arrivalTime, final int burstTime, int priority) {
+        this.processId = processId;
+        this.arrivalTime = arrivalTime;
+        this.burstTime = burstTime;
+        this.priority = priority;
+    }
 
     public ProcessDetails(final String processId, final int arrivalTime, final int burstTime) {
         this.processId = processId;
@@ -33,6 +41,10 @@ public int getTurnAroundTimeTime() {
         return turnAroundTime;
     }
 
+    public int getPriority() {
+        return priority;
+    }
+
     public void setProcessId(final String processId) {
         this.processId = processId;
     }

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

@@ -1,50 +1,47 @@
 package com.thealgorithms.scheduling;
 
+import com.thealgorithms.devutils.entities.ProcessDetails;
+
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.List;
 import java.util.PriorityQueue;
 
 /**
  * Preemptive Priority Scheduling Algorithm
+ *
  * @author [Bama Charan Chhandogi](https://www.github.com/BamaCharanChhandogi)
  */
+public class PreemptivePriorityScheduling {
+    protected final List<ProcessDetails> processes;
+    protected final List<String> ganttChart;
 
-class Process {
-    String name;
-    int arrivalTime;
-    int burstTime;
-    int priority;
-
-    Process(String name, int arrivalTime, int burstTime, int priority) {
-        this.name = name;
-        this.arrivalTime = arrivalTime;
-        this.burstTime = burstTime;
-        this.priority = priority;
+    public PreemptivePriorityScheduling(List<ProcessDetails> processes) {
+        this.processes = new ArrayList<>(processes);
+        this.ganttChart = new ArrayList<>();
     }
-}
 
-public final class PreemptivePriorityScheduling {
-    private PreemptivePriorityScheduling() {
-    }
-    public static List<String> preemptivePriorityScheduling(List<Process> processes) {
-        List<String> ganttChart = new ArrayList<>();
-        PriorityQueue<Process> readyQueue = new PriorityQueue<>(Comparator.comparingInt(p -> - p.priority));
+    public void scheduleProcesses() {
+        PriorityQueue<ProcessDetails> readyQueue = new PriorityQueue<>(
+                Comparator.comparingInt(ProcessDetails::getPriority).reversed()
+                        .thenComparingInt(ProcessDetails::getArrivalTime)
+        );
 
         int currentTime = 0;
+        int processIndex = 0;
 
-        while (!processes.isEmpty() || !readyQueue.isEmpty()) {
-            while (!processes.isEmpty() && processes.get(0).arrivalTime <= currentTime) {
-                readyQueue.add(processes.remove(0));
+        while (processIndex < processes.size() || !readyQueue.isEmpty()) {
+            while (processIndex < processes.size() && processes.get(processIndex).getArrivalTime() <= currentTime) {
+                readyQueue.add(processes.get(processIndex));
+                processIndex++;
             }
 
             if (!readyQueue.isEmpty()) {
-                Process currentProcess = readyQueue.poll();
+                ProcessDetails currentProcess = readyQueue.poll();
+                ganttChart.add(currentProcess.getProcessId());
+                currentProcess.setBurstTime(currentProcess.getBurstTime() - 1);
 
-                ganttChart.add(currentProcess.name);
-                currentProcess.burstTime--;
-
-                if (currentProcess.burstTime > 0) {
+                if (currentProcess.getBurstTime() > 0) {
                     readyQueue.add(currentProcess);
                 }
             } else {
@@ -53,7 +50,5 @@ public static List<String> preemptivePriorityScheduling(List<Process> processes)
 
             currentTime++;
         }
-
-        return ganttChart;
     }
 }

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

@@ -1,33 +1,52 @@
 package com.thealgorithms.scheduling;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import com.thealgorithms.devutils.entities.ProcessDetails;
+import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
-import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 /**
  * Test Cases of Preemptive Priority Scheduling Algorithm
+ *
  * @author [Bama Charan Chhandogi](https://www.github.com/BamaCharanChhandogi)
  */
 class PreemptivePrioritySchedulingTest {
 
     @Test
     void testPreemptivePriorityScheduling() {
-        // Arrange
-        List<Process> processes = new ArrayList<>();
-        processes.add(new Process("P1", 0, 5, 10));
-        processes.add(new Process("P2", 1, 4, 20));
-        processes.add(new Process("P3", 2, 2, 30));
-        processes.add(new Process("P4", 4, 1, 40));
+        List<ProcessDetails> processes = new ArrayList<>();
+        processes.add(new ProcessDetails("P1", 0, 5, 2));
+        processes.add(new ProcessDetails("P2", 1, 4, 4));
+        processes.add(new ProcessDetails("P3", 2, 2, 6));
+        processes.add(new ProcessDetails("P4", 4, 1, 8));
+
+        PreemptivePriorityScheduling scheduler = new PreemptivePriorityScheduling(processes);
+        scheduler.scheduleProcesses();
+
+        List<String> expectedSchedule = List.of(
+                "P1", "P2", "P3", "P3", "P4", "P2", "P2", "P2", "P1", "P1", "P1", "P1"
+        );
+
+        assertEquals(expectedSchedule, scheduler.ganttChart);
+    }
+
+    @Test
+    void testPreemptivePrioritySchedulingWithIdleTime() {
+        List<ProcessDetails> processes = new ArrayList<>();
+        processes.add(new ProcessDetails("P1", 2, 5, 3));
+        processes.add(new ProcessDetails("P2", 5, 3, 5));
+        processes.add(new ProcessDetails("P3", 7, 1, 9));
 
-        List<String> expectedGanttChart = Arrays.asList("P1", "P2", "P3", "P3", "P4", "P2", "P2", "P2", "P1", "P1", "P1", "P1");
+        PreemptivePriorityScheduling scheduler = new PreemptivePriorityScheduling(processes);
+        scheduler.scheduleProcesses();
 
-        // Act
-        List<String> actualGanttChart = PreemptivePriorityScheduling.preemptivePriorityScheduling(processes);
+        List<String> expectedSchedule = List.of(
+                "Idle", "Idle", "P1", "P1", "P1", "P2", "P2", "P3", "P2", "P1", "P1"
+        );
 
-        // Assert
-        assertEquals(expectedGanttChart, actualGanttChart);
+        assertEquals(expectedSchedule, scheduler.ganttChart);
     }
 }