Fix NearestElement.java & add comprehensive tests and formatted with clang for stack algorithms

Author: sgindeed

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

@@ -3,22 +3,23 @@
 import java.util.Stack;
 
 /**
- * Implementation of classic stack-based algorithms:
+ * Implements classic stack-based algorithms to find nearest elements.
+ *
+ * Algorithms included:
  * 1. Nearest Greater to Right
  * 2. Nearest Greater to Left
  * 3. Nearest Smaller to Right
  * 4. Nearest Smaller to Left
- *
- * These algorithms are fundamental for technical interviews and array-stack problems.
  */
 public final class NearestElement {
-
     // Private constructor to prevent instantiation
-    private NearestElement() {
-    }
+    private NearestElement() {}
 
+    /** Finds the nearest greater element to the right for each element in the array. */
     public static int[] nearestGreaterToRight(int[] arr) {
-        if (arr == null) throw new IllegalArgumentException("Input array cannot be null");
+        if (arr == null) {
+            throw new IllegalArgumentException("Input array cannot be null");
+        }
 
         int n = arr.length;
         int[] result = new int[n];
@@ -31,11 +32,15 @@ public static int[] nearestGreaterToRight(int[] arr) {
             result[i] = stack.isEmpty() ? -1 : stack.peek();
             stack.push(arr[i]);
         }
+
         return result;
     }
 
+    /** Finds the nearest greater element to the left for each element in the array. */
     public static int[] nearestGreaterToLeft(int[] arr) {
-        if (arr == null) throw new IllegalArgumentException("Input array cannot be null");
+        if (arr == null) {
+            throw new IllegalArgumentException("Input array cannot be null");
+        }
 
         int n = arr.length;
         int[] result = new int[n];
@@ -48,11 +53,15 @@ public static int[] nearestGreaterToLeft(int[] arr) {
             result[i] = stack.isEmpty() ? -1 : stack.peek();
             stack.push(arr[i]);
         }
+
         return result;
     }
 
+    /** Finds the nearest smaller element to the right for each element in the array. */
     public static int[] nearestSmallerToRight(int[] arr) {
-        if (arr == null) throw new IllegalArgumentException("Input array cannot be null");
+        if (arr == null) {
+            throw new IllegalArgumentException("Input array cannot be null");
+        }
 
         int n = arr.length;
         int[] result = new int[n];
@@ -65,11 +74,15 @@ public static int[] nearestSmallerToRight(int[] arr) {
             result[i] = stack.isEmpty() ? -1 : stack.peek();
             stack.push(arr[i]);
         }
+
         return result;
     }
 
+    /** Finds the nearest smaller element to the left for each element in the array. */
     public static int[] nearestSmallerToLeft(int[] arr) {
-        if (arr == null) throw new IllegalArgumentException("Input array cannot be null");
+        if (arr == null) {
+            throw new IllegalArgumentException("Input array cannot be null");
+        }
 
         int n = arr.length;
         int[] result = new int[n];
@@ -82,6 +95,7 @@ public static int[] nearestSmallerToLeft(int[] arr) {
             result[i] = stack.isEmpty() ? -1 : stack.peek();
             stack.push(arr[i]);
         }
+
         return result;
     }
-}
+}

src/test/java/com/thealgorithms/stacks/NearestElementTest.java

@@ -18,11 +18,7 @@ void testNearestGreaterToRight(int[] input, int[] expected) {
     }
 
     static Stream<Arguments> provideGreaterToRightTestCases() {
-        return Stream.of(
-            Arguments.of(new int[] {4, 5, 2, 10, 8}, new int[] {5, 10, 10, -1, -1}),
-            Arguments.of(new int[] {5}, new int[] {-1}),
-            Arguments.of(new int[] {}, new int[] {})
-        );
+        return Stream.of(Arguments.of(new int[] {4, 5, 2, 10, 8}, new int[] {5, 10, 10, -1, -1}), Arguments.of(new int[] {5}, new int[] {-1}), Arguments.of(new int[] {}, new int[] {}));
     }
 
     @ParameterizedTest
@@ -32,11 +28,7 @@ void testNearestGreaterToLeft(int[] input, int[] expected) {
     }
 
     static Stream<Arguments> provideGreaterToLeftTestCases() {
-        return Stream.of(
-            Arguments.of(new int[] {4, 5, 2, 10, 8}, new int[] {-1, -1, 5, -1, 10}),
-            Arguments.of(new int[] {5}, new int[] {-1}),
-            Arguments.of(new int[] {}, new int[] {})
-        );
+        return Stream.of(Arguments.of(new int[] {4, 5, 2, 10, 8}, new int[] {-1, -1, 5, -1, 10}), Arguments.of(new int[] {5}, new int[] {-1}), Arguments.of(new int[] {}, new int[] {}));
     }
 
     @ParameterizedTest
@@ -46,11 +38,7 @@ void testNearestSmallerToRight(int[] input, int[] expected) {
     }
 
     static Stream<Arguments> provideSmallerToRightTestCases() {
-        return Stream.of(
-            Arguments.of(new int[] {4, 5, 2, 10, 8}, new int[] {2, 2, -1, 8, -1}),
-            Arguments.of(new int[] {5}, new int[] {-1}),
-            Arguments.of(new int[] {}, new int[] {})
-        );
+        return Stream.of(Arguments.of(new int[] {4, 5, 2, 10, 8}, new int[] {2, 2, -1, 8, -1}), Arguments.of(new int[] {5}, new int[] {-1}), Arguments.of(new int[] {}, new int[] {}));
     }
 
     @ParameterizedTest
@@ -60,11 +48,7 @@ void testNearestSmallerToLeft(int[] input, int[] expected) {
     }
 
     static Stream<Arguments> provideSmallerToLeftTestCases() {
-        return Stream.of(
-            Arguments.of(new int[] {4, 5, 2, 10, 8}, new int[] {-1, 4, -1, 2, 2}),
-            Arguments.of(new int[] {5}, new int[] {-1}),
-            Arguments.of(new int[] {}, new int[] {})
-        );
+        return Stream.of(Arguments.of(new int[] {4, 5, 2, 10, 8}, new int[] {-1, 4, -1, 2, 2}), Arguments.of(new int[] {5}, new int[] {-1}), Arguments.of(new int[] {}, new int[] {}));
     }
 
     @Test
@@ -74,4 +58,4 @@ void testNullInput() {
         assertThrows(IllegalArgumentException.class, () -> NearestElement.nearestSmallerToRight(null));
         assertThrows(IllegalArgumentException.class, () -> NearestElement.nearestSmallerToLeft(null));
     }
-}
+}