Next Greater Element with Monotonic Stack

Author: kshitizsaini113

src/main/java/stack/next_greater_element/MonotonicStack.java

@@ -0,0 +1,75 @@
+package stack.next_greater_element;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+
+/**
+ * Implements a solution to the "Next Greater Element" problem using a Monotonic Stack.
+ *
+ * <p>A monotonic stack is a stack whose elements are always in a sorted order
+ * (either increasing or decreasing). This data structure is highly efficient for
+ * problems involving finding the next or previous greater/smaller element in an array.
+ *
+ * <p>This implementation finds the next greater element for each element in an array
+ * by iterating from right to left and maintaining a monotonically decreasing stack.
+ *
+ * <p><b>Complexity:</b>
+ * <ul>
+ *   <li>Time: O(N), where N is the number of elements in the array. Each element is
+ *       pushed and popped from the stack at most once.</li>
+ *   <li>Space: O(N), for storing the stack and the answer array.</li>
+ * </ul>
+ */
+public class MonotonicStack {
+    public final int[] answer; // Public for easy access in test cases
+    private final int[] array;
+
+    /**
+     * Initializes the data structure with the input array.
+     *
+     * @param array The input array for which to find the next greater elements.
+     */
+    public MonotonicStack(int[] array) {
+        this.array = array;
+        this.answer = new int[array.length];
+    }
+
+    /**
+     * Populates the {@code answer} array with the next greater element for each
+     * element in the input array.
+     *
+     * <p>The algorithm iterates through the input array from right to left. A stack
+     * is used to keep track of elements that could be the "next greater" for
+     * elements to their left.
+     *
+     * <p>For each element {@code array[i]}:
+     * <ol>
+     *   <li>While the stack is not empty and the element at the top of the stack is
+     *       less than or equal to {@code array[i]}, pop from the stack. This removes
+     *       elements that can never be the next greater element for anything to the left.</li>
+     *   <li>After popping, if the stack is empty, it means there is no greater element
+     *       to the right. Otherwise, the element at the top of the stack is the
+     *       next greater element.</li>
+     *   <li>Push the current element {@code array[i]} onto the stack to be a potential
+     *       next greater element for items to its left.</li>
+     * </ol>
+     */
+    public void findNextGreaterElement() {
+        // Using Deque is the recommended modern approach for stack implementations.
+        Deque<Integer> stack = new ArrayDeque<>();
+
+        for (int i = array.length - 1; i >= 0; i--) {
+            // Pop elements from the stack that are smaller than or equal to the current element.
+            while (!stack.isEmpty() && stack.peek() <= array[i]) {
+                stack.pop();
+            }
+
+            // If the stack is empty, no greater element exists to the right.
+            // Otherwise, the top of the stack is the next greater element.
+            answer[i] = stack.isEmpty() ? -1 : stack.peek();
+
+            // Push the current element onto the stack for future comparisons.
+            stack.push(array[i]);
+        }
+    }
+}

src/main/java/stack/next_greater_element/package-info.java

@@ -0,0 +1,32 @@
+/**
+ * Provides solutions for the "Next Greater Element" problem using a Monotonic Stack.
+ *
+ * <p>The "Next Greater Element" problem involves finding the first element to the
+ * right of a given element in an array that is strictly greater. If no such
+ * element exists, a default value (e.g., -1) is used.
+ *
+ * <h3>Core Implementation Strategy: Monotonic Stack</h3>
+ *
+ * <p>This package utilizes a <strong>Monotonic Stack</strong>, a highly efficient
+ * data structure for this category of problems. A monotonic stack maintains its
+ * elements in a sorted order (either increasing or decreasing).
+ *
+ * <p>The general algorithm is as follows:
+ * <ol>
+ *   <li>Iterate through the input array, typically from right to left.</li>
+ *   <li>For each element, pop elements from the stack that are less than or
+ *       equal to the current element. This ensures the stack's monotonic property
+ *       is maintained.</li>
+ *   <li>The element now at the top of the stack is the "next greater element" for
+ *       the current array element. If the stack is empty, no greater element exists.</li>
+ *   <li>Push the current element onto the stack.</li>
+ * </ol>
+ *
+ * <p>This approach guarantees that each element is pushed and popped at most once,
+ * resulting in an optimal time complexity of O(N).
+ *
+ * @version 1.0
+ * @see stack.next_greater_element.MonotonicStack
+ * @since 1.0
+ */
+package stack.next_greater_element;

src/test/java/stack/next_greater_element/MonotonicStackTest.java

@@ -0,0 +1,132 @@
+package stack.next_greater_element;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+
+/**
+ * Test suite for the {@link MonotonicStack} class.
+ */
+class MonotonicStackTest {
+
+    @Test
+    @DisplayName("Should find the next greater element in a general case array")
+    void findNextGreaterElement_generalCase() {
+        // Arrange
+        int[] array = {2, 1, 5, 6, 2, 3};
+        int[] expected = {5, 5, 6, -1, 3, -1};
+        MonotonicStack monotonicStack = new MonotonicStack(array);
+
+        // Act
+        monotonicStack.findNextGreaterElement();
+
+        // Assert
+        assertArrayEquals(expected, monotonicStack.answer, "Should correctly find next greater elements");
+    }
+
+    @Test
+    @DisplayName("Should return -1 for all elements in a strictly decreasing array")
+    void findNextGreaterElement_strictlyDecreasingArray() {
+        // Arrange
+        int[] array = {5, 4, 3, 2, 1};
+        int[] expected = {-1, -1, -1, -1, -1};
+        MonotonicStack monotonicStack = new MonotonicStack(array);
+
+        // Act
+        monotonicStack.findNextGreaterElement();
+
+        // Assert
+        assertArrayEquals(expected, monotonicStack.answer, "All elements should have -1 as next greater");
+    }
+
+    @Test
+    @DisplayName("Should find the correct next greater element in a strictly increasing array")
+    void findNextGreaterElement_strictlyIncreasingArray() {
+        // Arrange
+        int[] array = {1, 2, 3, 4, 5};
+        int[] expected = {2, 3, 4, 5, -1};
+        MonotonicStack monotonicStack = new MonotonicStack(array);
+
+        // Act
+        monotonicStack.findNextGreaterElement();
+
+        // Assert
+        assertArrayEquals(expected, monotonicStack.answer, "Each element's next greater should be its right neighbor");
+    }
+
+    @Test
+    @DisplayName("Should handle an array with duplicate values")
+    void findNextGreaterElement_withDuplicates() {
+        // Arrange
+        int[] array = {4, 5, 2, 2, 5};
+        int[] expected = {5, -1, 5, 5, -1};
+        MonotonicStack monotonicStack = new MonotonicStack(array);
+
+        // Act
+        monotonicStack.findNextGreaterElement();
+
+        // Assert
+        assertArrayEquals(expected, monotonicStack.answer, "Should handle duplicates correctly");
+    }
+
+    @Test
+    @DisplayName("Should handle an array with duplicate values")
+    void findNextGreaterElement_withDuplicates_multiple() {
+        // Arrange
+        int[] array = {4, 12, 5, 3, 1, 2, 5, 3, 1, 2, 4, 6};
+        int[] expected = {12, -1, 6, 5, 2, 5, 6, 4, 2, 4, 6, -1};
+        MonotonicStack monotonicStack = new MonotonicStack(array);
+
+        // Act
+        monotonicStack.findNextGreaterElement();
+
+        // Assert
+        assertArrayEquals(expected, monotonicStack.answer, "Should handle duplicates correctly");
+    }
+
+    @Test
+    @DisplayName("Should handle an array where all elements are the same")
+    void findNextGreaterElement_allSameElements() {
+        // Arrange
+        int[] array = {7, 7, 7, 7};
+        int[] expected = {-1, -1, -1, -1};
+        MonotonicStack monotonicStack = new MonotonicStack(array);
+
+        // Act
+        monotonicStack.findNextGreaterElement();
+
+        // Assert
+        assertArrayEquals(expected, monotonicStack.answer, "All elements should be -1 when all are identical");
+    }
+
+    @Test
+    @DisplayName("Should handle a single-element array")
+    void findNextGreaterElement_singleElementArray() {
+        // Arrange
+        int[] array = {100};
+        int[] expected = {-1};
+        MonotonicStack monotonicStack = new MonotonicStack(array);
+
+        // Act
+        monotonicStack.findNextGreaterElement();
+
+        // Assert
+        assertArrayEquals(expected, monotonicStack.answer, "A single element has no next greater element");
+    }
+
+    @Test
+    @DisplayName("Should handle an empty array without errors")
+    void findNextGreaterElement_emptyArray() {
+        // Arrange
+        int[] array = {};
+        int[] expected = {};
+        MonotonicStack monotonicStack = new MonotonicStack(array);
+
+        // Act
+        monotonicStack.findNextGreaterElement();
+
+        // Assert
+        assertArrayEquals(expected, monotonicStack.answer, "An empty input should result in an empty output");
+    }
+}