Add suggested changes

Hardvan · Hardvan · commit 6b5f794809bd · 2024-10-07T12:52:00.000+05:30
diff --git a/src/main/java/com/thealgorithms/scheduling/HighestResponseRatioNextScheduling.java b/src/main/java/com/thealgorithms/scheduling/HighestResponseRatioNextScheduling.java
@@ -4,72 +4,109 @@
 import java.util.Comparator;
 
 /**
- * The HighestResponseRatioNextScheduling class implements
- * the Highest Response Ratio Next (HRRN) scheduling algorithm.
- * HRRN is a non-preemptive scheduling algorithm that
- * selects the process with the highest response ratio for execution.
- * The response ratio is calculated as (waiting time + burst time) / burst time.
- * This algorithm aims to reduce the average waiting time
- * and improve overall system performance by balancing short and long processes.
+ * The {@code HighestResponseRatioNextScheduling} class implements the
+ * Highest Response Ratio Next (HRRN) scheduling algorithm.
+ * HRRN is a non-preemptive scheduling algorithm that selects the process with
+ * the highest response ratio for execution.
+ * The response ratio is calculated as:
+ *
+ * <pre>
+ *     Response Ratio = (waiting time + burst time) / burst time
+ * </pre>
+ *
+ * HRRN is designed to reduce the average waiting time and improve overall
+ * system performance by balancing between short and long processes,
+ * minimizing process starvation.
  */
 public final class HighestResponseRatioNextScheduling {
+
+    private static final int PROCESS_NOT_FOUND = -1;
+    private static final double INITIAL_MAX_RESPONSE_RATIO = -1.0;
+
     private HighestResponseRatioNextScheduling() {
     }
 
+    /**
+     * Represents a process in the scheduling algorithm.
+     */
+    private static class Process {
+        String name;
+        int arrivalTime;
+        int burstTime;
+        int turnAroundTime;
+        boolean finished;
+
+        Process(String name, int arrivalTime, int burstTime) {
+            this.name = name;
+            this.arrivalTime = arrivalTime;
+            this.burstTime = burstTime;
+            this.turnAroundTime = 0;
+            this.finished = false;
+        }
+
+        /**
+         * Calculates the response ratio for this process.
+         *
+         * @param currentTime The current time in the scheduling process.
+         * @return The response ratio for this process.
+         */
+        double calculateResponseRatio(int currentTime) {
+            return (double) (burstTime + currentTime - arrivalTime) / burstTime;
+        }
+    }
+
     /**
      * Calculates the Turn Around Time (TAT) for each process.
      *
+     * <p>Turn Around Time is calculated as the total time a process spends
+     * in the system from arrival to completion. It is the sum of the burst time
+     * and the waiting time.</p>
+     *
      * @param processNames Array of process names.
      * @param arrivalTimes Array of arrival times corresponding to each process.
-     * @param burstTimes   Array of burst times for each process.
+     * @param burstTimes Array of burst times for each process.
      * @param noOfProcesses The number of processes.
      * @return An array of Turn Around Times for each process.
      */
-    public static int[] calculateTurnAroundTime(String[] processNames, int[] arrivalTimes, int[] burstTimes, int noOfProcesses) {
+    public static int[] calculateTurnAroundTime(final String[] processNames, final int[] arrivalTimes, final int[] burstTimes, final int noOfProcesses) {
         int currentTime = 0;
         int[] turnAroundTime = new int[noOfProcesses];
-        boolean[] finishedProcess = new boolean[noOfProcesses];
-        int finishedProcessCount = 0;
-
-        // Sort by arrival times using a simple bubble sort for demonstration
-        int[] sortedIndices = sortIndicesByArrival(arrivalTimes);
-        arrivalTimes = Arrays.copyOf(arrivalTimes, arrivalTimes.length);
-        burstTimes = Arrays.copyOf(burstTimes, burstTimes.length);
-        processNames = Arrays.copyOf(processNames, processNames.length);
-
-        // Reorder the arrays based on sorted indices
-        int[] tempArrival = new int[noOfProcesses];
-        int[] tempBurst = new int[noOfProcesses];
-        String[] tempProcess = new String[noOfProcesses];
+        Process[] processes = new Process[noOfProcesses];
 
         for (int i = 0; i < noOfProcesses; i++) {
-            tempArrival[i] = arrivalTimes[sortedIndices[i]];
-            tempBurst[i] = burstTimes[sortedIndices[i]];
-            tempProcess[i] = processNames[sortedIndices[i]];
+            processes[i] = new Process(processNames[i], arrivalTimes[i], burstTimes[i]);
         }
 
-        arrivalTimes = tempArrival;
-        burstTimes = tempBurst;
-        processNames = tempProcess;
+        Arrays.sort(processes, Comparator.comparingInt(p -> p.arrivalTime));
 
+        int finishedProcessCount = 0;
         while (finishedProcessCount < noOfProcesses) {
-            currentTime = Math.max(currentTime, arrivalTimes[findNextProcess(arrivalTimes, finishedProcess, currentTime)]);
-            int loc = findHighestResponseRatio(processNames, arrivalTimes, burstTimes, finishedProcess, currentTime);
+            int nextProcessIndex = findNextProcess(processes, currentTime);
+            if (nextProcessIndex == PROCESS_NOT_FOUND) {
+                currentTime++;
+                continue;
+            }
 
-            turnAroundTime[loc] = currentTime + burstTimes[loc] - arrivalTimes[loc];
-            currentTime += burstTimes[loc];
-            finishedProcess[loc] = true;
+            Process currentProcess = processes[nextProcessIndex];
+            currentTime = Math.max(currentTime, currentProcess.arrivalTime);
+            currentProcess.turnAroundTime = currentTime + currentProcess.burstTime - currentProcess.arrivalTime;
+            currentTime += currentProcess.burstTime;
+            currentProcess.finished = true;
             finishedProcessCount++;
         }
 
+        for (int i = 0; i < noOfProcesses; i++) {
+            turnAroundTime[i] = processes[i].turnAroundTime;
+        }
+
         return turnAroundTime;
     }
 
     /**
      * Calculates the Waiting Time (WT) for each process.
      *
      * @param turnAroundTime The Turn Around Times for each process.
-     * @param burstTimes     The burst times for each process.
+     * @param burstTimes The burst times for each process.
      * @return An array of Waiting Times for each process.
      */
     public static int[] calculateWaitingTime(int[] turnAroundTime, int[] burstTimes) {
@@ -83,58 +120,39 @@ public static int[] calculateWaitingTime(int[] turnAroundTime, int[] burstTimes)
     /**
      * Finds the next process to be scheduled based on arrival times and the current time.
      *
-     * @param arrivalTimes    Array of arrival times for each process.
-     * @param finishedProcess Array indicating whether each process has finished.
-     * @param currentTime     The current time in the scheduling process.
-     * @return The index of the next process to be scheduled.
+     * @param processes Array of Process objects.
+     * @param currentTime The current time in the scheduling process.
+     * @return The index of the next process to be scheduled, or PROCESS_NOT_FOUND if no process is ready.
      */
-    private static int findNextProcess(int[] arrivalTimes, boolean[] finishedProcess, int currentTime) {
-        for (int i = 0; i < arrivalTimes.length; i++) {
-            if (!finishedProcess[i] && arrivalTimes[i] <= currentTime) {
-                return i;
-            }
-        }
-        return 0;
+    private static int findNextProcess(Process[] processes, int currentTime) {
+        return findHighestResponseRatio(processes, currentTime);
     }
 
     /**
      * Finds the process with the highest response ratio.
      *
-     * @param processNames    Array of process names.
-     * @param arrivalTimes    Array of arrival times for each process.
-     * @param burstTimes      Array of burst times for each process.
-     * @param finishedProcess Array indicating whether each process has finished.
-     * @param currentTime     The current time in the scheduling process.
-     * @return The index of the process with the highest response ratio.
+     * <p>The response ratio is calculated as:
+     * (waiting time + burst time) / burst time
+     * where waiting time = current time - arrival time</p>
+     *
+     * @param processes Array of Process objects.
+     * @param currentTime The current time in the scheduling process.
+     * @return The index of the process with the highest response ratio, or PROCESS_NOT_FOUND if no process is ready.
      */
-    private static int findHighestResponseRatio(String[] processNames, int[] arrivalTimes, int[] burstTimes, boolean[] finishedProcess, int currentTime) {
-        double maxResponseRatio = -1;
-        int loc = -1;
+    private static int findHighestResponseRatio(Process[] processes, int currentTime) {
+        double maxResponseRatio = INITIAL_MAX_RESPONSE_RATIO;
+        int maxIndex = PROCESS_NOT_FOUND;
 
-        for (int i = 0; i < processNames.length; i++) {
-            if (!finishedProcess[i] && arrivalTimes[i] <= currentTime) {
-                double responseRatio = (double) (burstTimes[i] + currentTime - arrivalTimes[i]) / burstTimes[i];
+        for (int i = 0; i < processes.length; i++) {
+            Process process = processes[i];
+            if (!process.finished && process.arrivalTime <= currentTime) {
+                double responseRatio = process.calculateResponseRatio(currentTime);
                 if (responseRatio > maxResponseRatio) {
                     maxResponseRatio = responseRatio;
-                    loc = i;
+                    maxIndex = i;
                 }
             }
         }
-        return loc;
-    }
-
-    /**
-     * Sorts the indices of the arrival times array in ascending order.
-     *
-     * @param arrivalTimes Array of arrival times for each process.
-     * @return An array of indices sorted by the corresponding arrival times.
-     */
-    private static int[] sortIndicesByArrival(int[] arrivalTimes) {
-        Integer[] indices = new Integer[arrivalTimes.length];
-        for (int i = 0; i < arrivalTimes.length; i++) {
-            indices[i] = i;
-        }
-        Arrays.sort(indices, Comparator.comparingInt(a -> arrivalTimes[a]));
-        return Arrays.stream(indices).mapToInt(Integer::intValue).toArray();
+        return maxIndex;
     }
 }
diff --git a/src/test/java/com/thealgorithms/scheduling/HighestResponseRatioNextSchedulingTest.java b/src/test/java/com/thealgorithms/scheduling/HighestResponseRatioNextSchedulingTest.java
@@ -44,4 +44,69 @@ public void testCompleteSchedulingScenario() {
         int[] waitingTimes = HighestResponseRatioNextScheduling.calculateWaitingTime(turnAroundTimes, burstTimes);
         assertArrayEquals(expectedWaitingTimes, waitingTimes, "Waiting Times do not match");
     }
+
+    @Test
+    public void testZeroProcesses() {
+        String[] processNames = {};
+        int[] arrivalTimes = {};
+        int[] burstTimes = {};
+        int noOfProcesses = 0;
+
+        int[] expectedTurnAroundTimes = {};
+        int[] actualTurnAroundTimes = HighestResponseRatioNextScheduling.calculateTurnAroundTime(processNames, arrivalTimes, burstTimes, noOfProcesses);
+
+        assertArrayEquals(expectedTurnAroundTimes, actualTurnAroundTimes, "Turn Around Times for zero processes should be an empty array");
+    }
+
+    @Test
+    public void testAllProcessesArriveAtSameTime() {
+        String[] processNames = {"A", "B", "C", "D"};
+        int[] arrivalTimes = {0, 0, 0, 0};
+        int[] burstTimes = {4, 3, 1, 2};
+        int noOfProcesses = 4;
+
+        int[] expectedTurnAroundTimes = {4, 10, 5, 7};
+        int[] actualTurnAroundTimes = HighestResponseRatioNextScheduling.calculateTurnAroundTime(processNames, arrivalTimes, burstTimes, noOfProcesses);
+
+        assertArrayEquals(expectedTurnAroundTimes, actualTurnAroundTimes, "Turn Around Times for processes arriving at the same time do not match");
+    }
+
+    @Test
+    public void testProcessesWithZeroBurstTime() {
+        String[] processNames = {"A", "B", "C"};
+        int[] arrivalTimes = {0, 1, 2};
+        int[] burstTimes = {3, 0, 2};
+        int noOfProcesses = 3;
+
+        int[] expectedTurnAroundTimes = {3, 2, 3};
+        int[] actualTurnAroundTimes = HighestResponseRatioNextScheduling.calculateTurnAroundTime(processNames, arrivalTimes, burstTimes, noOfProcesses);
+
+        assertArrayEquals(expectedTurnAroundTimes, actualTurnAroundTimes, "Turn Around Times for processes with zero burst time do not match");
+    }
+
+    @Test
+    public void testProcessesWithLargeGapsBetweenArrivals() {
+        String[] processNames = {"A", "B", "C"};
+        int[] arrivalTimes = {0, 100, 200};
+        int[] burstTimes = {10, 10, 10};
+        int noOfProcesses = 3;
+
+        int[] expectedTurnAroundTimes = {10, 10, 10};
+        int[] actualTurnAroundTimes = HighestResponseRatioNextScheduling.calculateTurnAroundTime(processNames, arrivalTimes, burstTimes, noOfProcesses);
+
+        assertArrayEquals(expectedTurnAroundTimes, actualTurnAroundTimes, "Turn Around Times for processes with large gaps between arrivals do not match");
+    }
+
+    @Test
+    public void testProcessesWithVeryLargeBurstTimes() {
+        String[] processNames = {"A", "B"};
+        int[] arrivalTimes = {0, 1};
+        int[] burstTimes = {Integer.MAX_VALUE/2, Integer.MAX_VALUE/2};
+        int noOfProcesses = 2;
+
+        int[] expectedTurnAroundTimes = {Integer.MAX_VALUE/2, Integer.MAX_VALUE-2};
+        int[] actualTurnAroundTimes = HighestResponseRatioNextScheduling.calculateTurnAroundTime(processNames, arrivalTimes, burstTimes, noOfProcesses);
+
+        assertArrayEquals(expectedTurnAroundTimes, actualTurnAroundTimes, "Turn Around Times for processes with very large burst times do not match");
+    }
 }
