Next Greater Element 1 with Monotonic Stack - Leetcode 496

Author: kshitizsaini113

src/main/java/stack/next_greater_element_i/MonotonicStack.java

@@ -0,0 +1,69 @@
+package stack.next_greater_element_i;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Solves the "Next Greater Element I" problem using a Monotonic Stack and a HashMap.
+ *
+ * <p>This approach is highly efficient because it avoids repeated searches. It works in
+ * two main phases:
+ * <ol>
+ *   <li><b>Pre-computation:</b> It iterates through the {@code nums2} array from right
+ *       to left, using a monotonic stack to find the next greater element for every
+ *       number in {@code nums2}. These results are stored in a map for instant retrieval.</li>
+ *   <li><b>Result Generation:</b> It then iterates through {@code nums1} and uses the
+ *       pre-computed map to look up the next greater element for each number, building
+ *       the final result array.</li>
+ * </ol>
+ *
+ * <p><b>Complexity:</b>
+ * <ul>
+ *   <li>Time: O(nums1.length + nums2.length), as each element in both arrays is
+ *       processed once.</li>
+ *   <li>Space: O(nums2.length) to store the map and the stack.</li>
+ * </ul>
+ *
+ * @see <a href="https://leetcode.com/problems/next-greater-element-i/">LeetCode 496: Next Greater Element I</a>
+ */
+public class MonotonicStack {
+
+    /**
+     * Finds the next greater element in {@code nums2} for each element in {@code nums1}.
+     *
+     * @param nums1 A subset of {@code nums2} for which to find the next greater elements.
+     * @param nums2 The array in which to search for the next greater elements.
+     * @return An array of the same length as {@code nums1}, where each element is the
+     * next greater element, or -1 if none exists.
+     */
+    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
+        // Map to store {element -> nextGreaterElement} for nums2
+        Map<Integer, Integer> nextGreaterMap = new HashMap<>();
+        // Monotonic stack to keep track of elements in decreasing order
+        Deque<Integer> stack = new ArrayDeque<>();
+
+        // 1. Pre-compute next greater elements for all numbers in nums2
+        for (int i = nums2.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() <= nums2[i]) {
+                stack.pop();
+            }
+
+            // The top of the stack is the next greater element. If stack is empty, there is none.
+            nextGreaterMap.put(nums2[i], stack.isEmpty() ? -1 : stack.peek());
+
+            // Push the current element onto the stack for future comparisons
+            stack.push(nums2[i]);
+        }
+
+        // 2. Build the result array using the pre-computed map
+        int[] result = new int[nums1.length];
+        for (int i = 0; i < nums1.length; i++) {
+            result[i] = nextGreaterMap.get(nums1[i]);
+        }
+
+        return result;
+    }
+}

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

@@ -0,0 +1,34 @@
+/**
+ * Provides a solution for the "Next Greater Element I" problem.
+ *
+ * <p>The problem is defined as follows: Given two distinct integer arrays, {@code nums1} and
+ * {@code nums2}, where {@code nums1} is a subset of {@code nums2}, find the next greater
+ * element in {@code nums2} for each element in {@code nums1}. The "next greater element"
+ * of a number {@code x} is the first number to its right in the same array that is
+ * larger than {@code x}. If no such element exists, the answer is -1.
+ *
+ * <h3>Core Implementation Strategy</h3>
+ *
+ * <p>A naive approach of searching for each element of {@code nums1} in {@code nums2} and then
+ * searching for its next greater element would be inefficient, leading to a complexity of
+ * roughly O(N*M).
+ *
+ * <p>A much more optimal, two-pass approach is used here:
+ * <ol>
+ *   <li><b>Pre-computation:</b> First, we process the larger array, {@code nums2}, to find the
+ *       next greater element for <em>every</em> number within it. This is efficiently
+ *       achieved using a <strong>Monotonic Stack</strong>. The results are stored in a
+ *       {@code HashMap} mapping each number to its next greater element.</li>
+ *   <li><b>Querying:</b> Second, we iterate through the smaller array, {@code nums1}. For each
+ *       number, we perform a quick O(1) lookup in the pre-computed map to find its
+ *       corresponding next greater element.</li>
+ * </ol>
+ *
+ * <p>This strategy reduces the overall time complexity to O(nums1.length + nums2.length),
+ * as each array is traversed only once.
+ *
+ * @version 1.0
+ * @see <a href="https://leetcode.com/problems/next-greater-element-i/">LeetCode 496: Next Greater Element I</a>
+ * @since 1.0
+ */
+package stack.next_greater_element_i;

src/test/java/stack/next_greater_element_i/MonotonicStackTest.java

@@ -0,0 +1,105 @@
+package stack.next_greater_element_i;
+
+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 {
+
+    private final MonotonicStack monotonicStack = new MonotonicStack();
+
+    @Test
+    @DisplayName("Should pass the primary LeetCode example")
+    void testLeetCodeExample1() {
+        // Arrange
+        int[] nums1 = {4, 1, 2};
+        int[] nums2 = {1, 3, 4, 2};
+        int[] expected = {-1, 3, -1};
+
+        // Act
+        int[] result = monotonicStack.nextGreaterElement(nums1, nums2);
+
+        // Assert
+        assertArrayEquals(expected, result, "Should find the correct next greater elements");
+    }
+
+    @Test
+    @DisplayName("Should pass the second LeetCode example")
+    void testLeetCodeExample2() {
+        // Arrange
+        int[] nums1 = {2, 4};
+        int[] nums2 = {1, 2, 3, 4};
+        int[] expected = {3, -1};
+
+        // Act
+        int[] result = monotonicStack.nextGreaterElement(nums1, nums2);
+
+        // Assert
+        assertArrayEquals(expected, result, "Should handle cases where the element is at the end");
+    }
+
+    @Test
+    @DisplayName("Should return -1 for all elements when nums2 is strictly decreasing")
+    void testStrictlyDecreasingArray() {
+        // Arrange
+        int[] nums1 = {5, 3, 1};
+        int[] nums2 = {5, 4, 3, 2, 1};
+        int[] expected = {-1, -1, -1};
+
+        // Act
+        int[] result = monotonicStack.nextGreaterElement(nums1, nums2);
+
+        // Assert
+        assertArrayEquals(expected, result, "All results should be -1 for a decreasing array");
+    }
+
+    @Test
+    @DisplayName("Should find the adjacent element when nums2 is strictly increasing")
+    void testStrictlyIncreasingArray() {
+        // Arrange
+        int[] nums1 = {1, 2, 3, 4};
+        int[] nums2 = {1, 2, 3, 4, 5};
+        int[] expected = {2, 3, 4, 5};
+
+        // Act
+        int[] result = monotonicStack.nextGreaterElement(nums1, nums2);
+
+        // Assert
+        assertArrayEquals(expected, result, "Next greater element should be the next one in sequence");
+    }
+
+    @Test
+    @DisplayName("Should work correctly when nums1 is a permutation of nums2")
+    void testWhenNums1IsPermutationOfNums2() {
+        // Arrange
+        int[] nums1 = {1, 3, 5, 2, 4};
+        int[] nums2 = {1, 3, 5, 2, 4};
+        int[] expected = {3, 5, -1, 4, -1};
+
+        // Act
+        int[] result = monotonicStack.nextGreaterElement(nums1, nums2);
+
+        // Assert
+        assertArrayEquals(expected, result, "Should handle the case where nums1 and nums2 are the same");
+    }
+
+    @Test
+    @DisplayName("Should handle a more complex, mixed scenario")
+    void testComplexScenario() {
+        // Arrange
+        int[] nums1 = {13, 7, 6, 12};
+        int[] nums2 = {1, 3, 7, 4, 6, 9, 13, 12, 11};
+        // NGE map for nums2: {1:3, 3:7, 7:9, 4:6, 6:9, 9:13, 13:-1, 12:-1, 11:-1}
+        int[] expected = {-1, 9, 9, -1};
+
+        // Act
+        int[] result = monotonicStack.nextGreaterElement(nums1, nums2);
+
+        // Assert
+        assertArrayEquals(expected, result, "Should correctly process a complex sequence");
+    }
+}