Style: Fix naming and formatting across multiple algorithm files

src/main/java/com/thealgorithms/datastructures/caches/FIFOCache.java

@@ -9,6 +9,8 @@
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;
 import java.util.function.BiConsumer;
+import java.util.logging.Level;
+import java.util.logging.Logger;
 
 /**
  * A thread-safe generic cache implementation using the First-In-First-Out eviction policy.
@@ -35,6 +37,8 @@
  */
 public final class FIFOCache<K, V> {
 
+    private static final Logger LOGGER = Logger.getLogger(FIFOCache.class.getName());
+
     private final int capacity;
     private final long defaultTTL;
     private final Map<K, CacheEntry<V>> cache;
@@ -255,8 +259,8 @@ private void notifyEviction(K key, V value) {
         if (evictionListener != null) {
             try {
                 evictionListener.accept(key, value);
-            } catch (Exception e) {
-                System.err.println("Eviction listener failed: " + e.getMessage());
+            } catch (IllegalArgumentException | IllegalStateException e) {
+                LOGGER.log(Level.WARNING, "Eviction listener failed for key: " + key, e);
             }
         }
     }

src/main/java/com/thealgorithms/datastructures/caches/LIFOCache.java

@@ -12,6 +12,8 @@
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;
 import java.util.function.BiConsumer;
+import java.util.logging.Level;
+import java.util.logging.Logger;
 
 /**
  * A thread-safe generic cache implementation using the Last-In-First-Out eviction policy.
@@ -38,6 +40,8 @@
  */
 public final class LIFOCache<K, V> {
 
+    private static final Logger LOGGER = Logger.getLogger(LIFOCache.class.getName());
+
     private final int capacity;
     private final long defaultTTL;
     private final Map<K, CacheEntry<V>> cache;
@@ -268,8 +272,8 @@ private void notifyEviction(K key, V value) {
         if (evictionListener != null) {
             try {
                 evictionListener.accept(key, value);
-            } catch (Exception e) {
-                System.err.println("Eviction listener failed: " + e.getMessage());
+            } catch (IllegalArgumentException | IllegalStateException e) {
+                LOGGER.log(Level.WARNING, "Eviction listener failed for key: " + key, e);
             }
         }
     }

src/main/java/com/thealgorithms/datastructures/lists/RandomNode.java

@@ -2,7 +2,7 @@
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Random;
+import java.security.SecureRandom;
 
 /**
  * @author <a href="https://github.com/skmodi649">Suraj Kumar</a>
@@ -31,7 +31,7 @@ public class RandomNode {
 
     private final List<Integer> list;
     private int size;
-    private static final Random RAND = new Random();
+    private static final SecureRandom RAND = new SecureRandom();
 
     static class ListNode {
 

src/main/java/com/thealgorithms/datastructures/lists/SkipList.java

@@ -5,7 +5,7 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.Objects;
-import java.util.Random;
+import java.security.SecureRandom;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
@@ -292,7 +292,7 @@ public static class BernoulliHeightStrategy implements HeightStrategy {
         private final double probability;
 
         private static final double DEFAULT_PROBABILITY = 0.5;
-        private static final Random RANDOM = new Random();
+        private static final SecureRandom RANDOM = new SecureRandom();
 
         public BernoulliHeightStrategy() {
             this.probability = DEFAULT_PROBABILITY;

src/main/java/com/thealgorithms/dynamicprogramming/LongestArithmeticSubsequence.java

@@ -2,8 +2,8 @@
 
 import java.util.HashMap;
 
-@SuppressWarnings({"rawtypes", "unchecked"})
-final class LongestArithmeticSubsequence {
+@SuppressWarnings({ "rawtypes", "unchecked" })
+public final class LongestArithmeticSubsequence {
     private LongestArithmeticSubsequence() {
     }
 

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

@@ -27,15 +27,22 @@ private void evaluateWaitingTime() {
             return;
         }
 
-        int waitingTime = 0;
         int burstTime = processes.get(0).getBurstTime();
+        if (burstTime < 0) {
+            throw new IllegalArgumentException("Burst time cannot be negative for process: " + processes.get(0).getProcessId());
+        }
 
+        int waitingTime = 0;
         processes.get(0).setWaitingTime(waitingTime); // for the first process, waiting time will be 0.
 
         for (int i = 1; i < processesNumber; i++) {
+            int currentBurstTime = processes.get(i).getBurstTime();
+            if (currentBurstTime < 0) {
+                throw new IllegalArgumentException("Burst time cannot be negative for process: " + processes.get(i).getProcessId());
+            }
             processes.get(i).setWaitingTime(waitingTime + burstTime);
             waitingTime = processes.get(i).getWaitingTime();
-            burstTime = processes.get(i).getBurstTime();
+            burstTime = currentBurstTime;
         }
     }
 

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

@@ -18,6 +18,20 @@ public class RRScheduling {
     private int quantumTime;
 
     RRScheduling(final List<ProcessDetails> processes, int quantumTime) {
+        if (quantumTime <= 0) {
+            throw new IllegalArgumentException("Quantum time must be positive.");
+        }
+        for (ProcessDetails process : processes) {
+            if (process.getBurstTime() < 0) {
+                throw new IllegalArgumentException("Burst time cannot be negative for process: " + process.getProcessId());
+            }
+            if (process.getArrivalTime() < 0) {
+                throw new IllegalArgumentException("Arrival time cannot be negative for process: " + process.getProcessId());
+            }
+            if (process.getProcessId() == null || !process.getProcessId().matches("[a-zA-Z0-9_-]+")) {
+                throw new IllegalArgumentException("Invalid process ID: " + process.getProcessId());
+            }
+        }
         this.processes = processes;
         this.quantumTime = quantumTime;
     }

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

@@ -30,14 +30,27 @@ public SRTFScheduling(ArrayList<ProcessDetails> processes) {
         this.processes = processes;
     }
 
+    private static void validateProcess(ProcessDetails process) {
+        if (process.getBurstTime() < 0) {
+            throw new IllegalArgumentException("Burst time cannot be negative for process: " + process.getProcessId());
+        }
+        if (process.getArrivalTime() < 0) {
+            throw new IllegalArgumentException("Arrival time cannot be negative for process: " + process.getProcessId());
+        }
+        if (process.getProcessId() == null || !process.getProcessId().matches("[a-zA-Z0-9_-]+")) {
+            throw new IllegalArgumentException("Invalid process ID: " + process.getProcessId());
+        }
+    }
+
     public void evaluateScheduling() {
         int time = 0;
         int cr = 0; // cr=current running process, time= units of time
         int n = processes.size();
         int[] remainingTime = new int[n];
 
-        /* calculating remaining time of every process and total units of time */
+        /* validating and calculating remaining time of every process and total units of time */
         for (int i = 0; i < n; i++) {
+            validateProcess(processes.get(i));
             remainingTime[i] = processes.get(i).getBurstTime();
             time += processes.get(i).getBurstTime();
         }

src/main/java/com/thealgorithms/stacks/StackPostfixNotation.java

@@ -7,12 +7,15 @@
 /**
  * Utility class for evaluating postfix expressions using integer arithmetic.
  * <p>
- * Postfix notation, also known as Reverse Polish Notation (RPN), is a mathematical notation in which operators follow their operands.
- * This class provides a method to evaluate expressions written in postfix notation.
+ * Postfix notation, also known as Reverse Polish Notation (RPN), is a
+ * mathematical notation in which operators follow their operands.
+ * This class provides a method to evaluate expressions written in postfix
+ * notation.
  * </p>
  * <p>
  * For more information on postfix notation, refer to
- * <a href="https://en.wikipedia.org/wiki/Reverse_Polish_notation">Reverse Polish Notation (RPN) on Wikipedia</a>.
+ * <a href="https://en.wikipedia.org/wiki/Reverse_Polish_notation">Reverse
+ * Polish Notation (RPN) on Wikipedia</a>.
  * </p>
  */
 public final class StackPostfixNotation {
@@ -22,16 +25,16 @@ private StackPostfixNotation() {
     private static BiFunction<Integer, Integer, Integer> getOperator(final String operationSymbol) {
         // note the order of operands
         switch (operationSymbol) {
-        case "+":
-            return (a, b) -> b + a;
-        case "-":
-            return (a, b) -> b - a;
-        case "*":
-            return (a, b) -> b * a;
-        case "/":
-            return (a, b) -> b / a;
-        default:
-            throw new IllegalArgumentException("exp contains an unknown operation.");
+            case "+":
+                return (a, b) -> b + a;
+            case "-":
+                return (a, b) -> b - a;
+            case "*":
+                return (a, b) -> b * a;
+            case "/":
+                return (a, b) -> b / a;
+            default:
+                throw new IllegalArgumentException("exp contains an unknown operation.");
         }
     }
 
@@ -64,9 +67,17 @@ private static void consumeExpression(Stack<Integer> s, final String exp) {
     public static int postfixEvaluate(final String exp) {
         Stack<Integer> s = new Stack<>();
         consumeExpression(s, exp);
-        if (s.size() != 1) {
-            throw new IllegalArgumentException("exp is not a proper postfix expression.");
-        }
-        return s.pop();
-    }
+     // Inside the evaluation loop when an operator is found:
+if (s.size() < 2) {
+    throw new IllegalArgumentException("Invalid expression: not enough operands.");
+}
+int b = s.pop();
+int a = s.pop();
+// perform operation and push result
+
+// ... after the loop finishes ...
+if (s.size() != 1) {
+    throw new IllegalArgumentException("exp is not a proper postfix expression.");
 }
+return s.pop();   }
+} ̰