Enhance code readability with comments and formatting

Added comments and improved code formatting for clarity.

Author: ChaitanyaShah26

src/main/java/com/thealgorithms/scheduling/Preemptive&NonPreemptiveScheduling.java

@@ -1,8 +1,16 @@
-import java.util.Scanner;
 import java.util.Arrays;
 import java.util.Comparator;
+import java.util.Scanner;
 
+/**
+ * Implements and compares non-preemptive (SJF) and preemptive (SRTF) CPU
+ * scheduling algorithms.
+ */
 class SchedulingAlgorithms {
+
+    /**
+     * Represents a process with its attributes for scheduling.
+     */
     static class Process {
         private int pid;
         private int priority;
@@ -20,8 +28,10 @@ static class Process {
             this.arrivalTime = arrivalTime;
             this.burstTime = burstTime;
             this.remainingTime = burstTime;
-            this.responseTime = -1;
+            this.responseTime = -1; // Initialize response time as not set
         }
+
+        // --- Getters ---
         public int getPid() { return pid; }
         public int getPriority() { return priority; }
         public int getArrivalTime() { return arrivalTime; }
@@ -32,6 +42,7 @@ static class Process {
         public int getTurnaroundTime() { return turnaroundTime; }
         public int getResponseTime() { return responseTime; }
 
+        // --- Setters ---
         public void setRemainingTime(int remainingTime) { this.remainingTime = remainingTime; }
         public void setCompletionTime(int completionTime) { this.completionTime = completionTime; }
         public void setWaitingTime(int waitingTime) { this.waitingTime = waitingTime; }
@@ -40,6 +51,7 @@ static class Process {
     }
 
     public static void main(String[] args) {
+        // Use try-with-resources to ensure the scanner is closed automatically
         try (Scanner sc = new Scanner(System.in)) {
             System.out.print("Enter number of processes: ");
             int n = sc.nextInt();
@@ -63,19 +75,24 @@ public static void main(String[] args) {
             int choice = sc.nextInt();
 
             switch (choice) {
-                case 1:
-                    nonPreemptive(processes);
-                    break;
-                case 2:
-                    preemptive(processes);
-                    break;
-                default:
-                    System.out.println("Invalid choice. Exiting.");
-                    return;
+            case 1:
+                nonPreemptive(processes);
+                break;
+            case 2:
+                preemptive(processes);
+                break;
+            default:
+                System.out.println("Invalid choice. Exiting.");
+                return;
             }
         }
     }
-    
+
+    /**
+     * Executes the Non-Preemptive Shortest Job First (SJF) scheduling
+     * algorithm. Tie-breaking is done based on priority.
+     * @param processes Array of processes to be scheduled.
+     */
     private static void nonPreemptive(Process[] processes) {
         int n = processes.length;
         int completedProcesses = 0;
@@ -87,13 +104,16 @@ private static void nonPreemptive(Process[] processes) {
             int minBurstTime = Integer.MAX_VALUE;
             int highestPriority = Integer.MAX_VALUE;
 
+            // Find the process with the shortest burst time among arrived processes
             for (int i = 0; i < n; i++) {
                 if (processes[i].getArrivalTime() <= currentTime && !isCompleted[i]) {
                     if (processes[i].getBurstTime() < minBurstTime) {
                         minBurstTime = processes[i].getBurstTime();
                         highestPriority = processes[i].getPriority();
                         selectedProcessIndex = i;
-                    } 
+                    }
+                    // Tie-breaker: if burst times are equal, choose based on
+                    // priority
                     else if (processes[i].getBurstTime() == minBurstTime) {
                         if (processes[i].getPriority() < highestPriority) {
                             highestPriority = processes[i].getPriority();
@@ -105,26 +125,34 @@ else if (processes[i].getBurstTime() == minBurstTime) {
 
             if (selectedProcessIndex != -1) {
                 Process currentProcess = processes[selectedProcessIndex];
-                
+
+                // Set response time if it's the first time the process runs
                 if (currentProcess.getResponseTime() == -1) {
-                     currentProcess.setResponseTime(currentTime - currentProcess.getArrivalTime());
+                    currentProcess.setResponseTime(currentTime - currentProcess.getArrivalTime());
                 }
 
                 currentProcess.setWaitingTime(currentTime - currentProcess.getArrivalTime());
                 currentTime += currentProcess.getBurstTime();
                 currentProcess.setCompletionTime(currentTime);
-                currentProcess.setTurnaroundTime(currentProcess.getCompletionTime() - currentProcess.getArrivalTime());
-                
+                currentProcess.setTurnaroundTime(
+                    currentProcess.getCompletionTime() - currentProcess.getArrivalTime());
+
                 isCompleted[selectedProcessIndex] = true;
                 completedProcesses++;
             } else {
+                // If no process is available, increment time
                 currentTime++;
             }
         }
 
         printResults(processes, "Non-Preemptive SJF (with Priority) Scheduling");
     }
 
+    /**
+     * Executes the Preemptive Shortest Remaining Time First (SRTF) scheduling
+     * algorithm.
+     * @param processes Array of processes to be scheduled.
+     */
     private static void preemptive(Process[] processes) {
         int n = processes.length;
         int completedProcesses = 0;
@@ -134,6 +162,8 @@ private static void preemptive(Process[] processes) {
             int shortestJobIndex = -1;
             int minRemainingTime = Integer.MAX_VALUE;
 
+            // Find the process with the minimum remaining time among the arrived
+            // processes
             for (int i = 0; i < n; i++) {
                 if (processes[i].getArrivalTime() <= currentTime && processes[i].getRemainingTime() > 0) {
                     if (processes[i].getRemainingTime() < minRemainingTime) {
@@ -150,19 +180,25 @@ private static void preemptive(Process[] processes) {
 
             Process currentProcess = processes[shortestJobIndex];
 
+            // Set response time when the process gets CPU for the first time
             if (currentProcess.getResponseTime() == -1) {
                 currentProcess.setResponseTime(currentTime - currentProcess.getArrivalTime());
             }
 
+            // Decrement remaining time and increment current time
             currentProcess.setRemainingTime(currentProcess.getRemainingTime() - 1);
             currentTime++;
 
+            // If a process is completed
             if (currentProcess.getRemainingTime() == 0) {
                 completedProcesses++;
                 currentProcess.setCompletionTime(currentTime);
-                currentProcess.setTurnaroundTime(currentProcess.getCompletionTime() - currentProcess.getArrivalTime());
-                currentProcess.setWaitingTime(currentProcess.getTurnaroundTime() - currentProcess.getBurstTime());
-                 
+                currentProcess.setTurnaroundTime(
+                    currentProcess.getCompletionTime() - currentProcess.getArrivalTime());
+                currentProcess.setWaitingTime(
+                    currentProcess.getTurnaroundTime() - currentProcess.getBurstTime());
+
+                // Ensure waiting time is not negative
                 if (currentProcess.getWaitingTime() < 0) {
                     currentProcess.setWaitingTime(0);
                 }
@@ -172,23 +208,30 @@ private static void preemptive(Process[] processes) {
         printResults(processes, "Preemptive SRTF Scheduling");
     }
 
+    /**
+     * Prints the scheduling results in a formatted table.
+     * @param processes Array of completed processes.
+     * @param title The title of the scheduling algorithm.
+     */
     private static void printResults(Process[] processes, String title) {
         System.out.println("\n" + title);
-        System.out.printf("%-10s%-10s%-15s%-15s%-17s%-15s%-17s%-15s\n",
-                "Process", "Priority", "Arrival Time", "Burst Time",
-                "Completion Time", "Waiting Time", "Turnaround Time", "Response Time");
+        System.out.printf("%-10s%-10s%-15s%-15s%-17s%-15s%-17s%-15s\n", "Process", "Priority",
+            "Arrival Time", "Burst Time", "Completion Time", "Waiting Time", "Turnaround Time",
+            "Response Time");
 
-        double totalWT = 0, totalTAT = 0;
+        double totalWT = 0;
+        double totalTAT = 0;
 
+        // Define a comparator to sort processes by PID for consistent output
         Comparator<Process> byPid = (p1, p2) -> Integer.compare(p1.getPid(), p2.getPid());
         Arrays.sort(processes, byPid);
 
         for (Process p : processes) {
             totalWT += p.getWaitingTime();
             totalTAT += p.getTurnaroundTime();
-            System.out.printf("%-10d%-10d%-15d%-15d%-17d%-15d%-17d%-15d\n",
-                    p.getPid(), p.getPriority(), p.getArrivalTime(), p.getBurstTime(),
-                    p.getCompletionTime(), p.getWaitingTime(), p.getTurnaroundTime(), p.getResponseTime());
+            System.out.printf("%-10d%-10d%-15d%-15d%-17d%-15d%-17d%-15d\n", p.getPid(),
+                p.getPriority(), p.getArrivalTime(), p.getBurstTime(), p.getCompletionTime(),
+                p.getWaitingTime(), p.getTurnaroundTime(), p.getResponseTime());
         }
 
         System.out.printf("\nAverage Waiting Time: %.2f\n", totalWT / processes.length);