Add print statements to all NearestElementTest methods

Author: Sahilagarwal623

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

@@ -0,0 +1,75 @@
+package datastructures.stacks;
+
+import java.util.Arrays;
+import java.util.Stack;
+
+/**
+ * The {@code NearestElement} class provides static utility methods to find the nearest greater or smaller elements
+ * to the left or right of each element in an integer array using stack-based algorithms.
+ * 
+ * <p>Each method runs in O(n) time complexity by maintaining a monotonic stack:
+ * <ul>
+ *   <li>{@code nearestGreaterToRight}: Finds the nearest greater element to the right of each element.</li>
+ *   <li>{@code nearestGreaterToLeft}: Finds the nearest greater element to the left of each element.</li>
+ *   <li>{@code nearestSmallerToRight}: Finds the nearest smaller element to the right of each element.</li>
+ *   <li>{@code nearestSmallerToLeft}: Finds the nearest smaller element to the left of each element.</li>
+ * </ul>
+ * If no such element exists for a position, -1 is returned at that index.
+ */
+public class NearestElement {
+    public static int[] nearestGreaterToRight(int[] arr) {
+        int n = arr.length;
+        int[] res = new int[n];
+        Stack<Integer> st = new Stack<>();
+        for (int i = n - 1; i >= 0; i--) {
+            while (!st.isEmpty() && st.peek() <= arr[i]) st.pop();
+            res[i] = st.isEmpty() ? -1 : st.peek();
+            st.push(arr[i]);
+        }
+        return res;
+    }
+
+    public static int[] nearestGreaterToLeft(int[] arr) {
+        int n = arr.length;
+        int[] res = new int[n];
+        Stack<Integer> st = new Stack<>();
+        for (int i = 0; i < n; i++) {
+            while (!st.isEmpty() && st.peek() <= arr[i]) st.pop();
+            res[i] = st.isEmpty() ? -1 : st.peek();
+            st.push(arr[i]);
+        }
+        return res;
+    }
+
+    public static int[] nearestSmallerToRight(int[] arr) {
+        int n = arr.length;
+        int[] res = new int[n];
+        Stack<Integer> st = new Stack<>();
+        for (int i = n - 1; i >= 0; i--) {
+            while (!st.isEmpty() && st.peek() >= arr[i]) st.pop();
+            res[i] = st.isEmpty() ? -1 : st.peek();
+            st.push(arr[i]);
+        }
+        return res;
+    }
+
+    public static int[] nearestSmallerToLeft(int[] arr) {
+        int n = arr.length;
+        int[] res = new int[n];
+        Stack<Integer> st = new Stack<>();
+        for (int i = 0; i < n; i++) {
+            while (!st.isEmpty() && st.peek() >= arr[i]) st.pop();
+            res[i] = st.isEmpty() ? -1 : st.peek();
+            st.push(arr[i]);
+        }
+        return res;
+    }
+
+    public static void main(String[] args) {
+        int[] arr = {4, 5, 2, 10, 8};
+        System.out.println("Nearest Greater to Right: " + Arrays.toString(nearestGreaterToRight(arr)));
+        System.out.println("Nearest Greater to Left: " + Arrays.toString(nearestGreaterToLeft(arr)));
+        System.out.println("Nearest Smaller to Right: " + Arrays.toString(nearestSmallerToRight(arr)));
+        System.out.println("Nearest Smaller to Left: " + Arrays.toString(nearestSmallerToLeft(arr)));
+    }
+}

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

@@ -0,0 +1,47 @@
+package com.thealgorithms.stacks;
+
+import java.util.Arrays;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import org.junit.jupiter.api.Test;
+
+import datastructures.stacks.NearestElement;
+
+class NearestElementTest {
+
+    @Test
+    void testNearestGreaterToRight() {
+        int[] arr = {4, 5, 2, 10, 8};
+        int[] result = NearestElement.nearestGreaterToRight(arr);
+        System.out.println("nearestGreaterToRight: " + Arrays.toString(result));
+        int[] expected = {5, 10, 10, -1, -1};
+        assertArrayEquals(expected, result);
+    }
+
+    @Test
+    void testNearestGreaterToLeft() {
+        int[] arr = {4, 5, 2, 10, 8};
+        int[] result = NearestElement.nearestGreaterToLeft(arr);
+        System.out.println("nearestGreaterToLeft: " + Arrays.toString(result));
+        int[] expected = {-1, -1, 5, -1, 10};
+        assertArrayEquals(expected, result);
+    }
+
+    @Test
+    void testNearestSmallerToRight() {
+        int[] arr = {4, 5, 2, 10, 8};
+        int[] result = NearestElement.nearestSmallerToRight(arr);
+        System.out.println("nearestSmallerToRight: " + Arrays.toString(result));
+        int[] expected = {2, 2, -1, 8, -1};
+        assertArrayEquals(expected, result);
+    }
+
+    @Test
+    void testNearestSmallerToLeft() {
+        int[] arr = {4, 5, 2, 10, 8};
+        int[] result = NearestElement.nearestSmallerToLeft(arr);
+        System.out.println("nearestSmallerToLeft: " + Arrays.toString(result));
+        int[] expected = {-1, 4, -1, 2, 2};
+        assertArrayEquals(expected, result);
+    }
+}