Next Greater Element I - Practice Coding Problems

Next Greater Element I - Problem

Next Greater Element I is a classic stack-based problem that teaches you how to efficiently find relationships between array elements.

Given two arrays nums1 and nums2, where nums1 is a subset of nums2, your task is to find the next greater element for each element in nums1.

The next greater element of an element x is the first element to the right of x that is greater than x. If no such element exists, return -1.

Example: If nums2 = [1,3,4,2] and we're looking for the next greater element of 3, the answer is 4 because 4 is the first element to the right of 3 that is greater than 3.

Goal: Return an array where each position contains the next greater element for the corresponding element in nums1.

Input & Output

example_1.py — Basic Case

$ Input: nums1 = [4,1,2], nums2 = [1,3,4,2]

› Output: [-1,3,-1]

💡 Note: For 4: no element to the right is greater, so -1. For 1: first greater element to the right is 3. For 2: no element to the right is greater, so -1.

example_2.py — All Found

$ Input: nums1 = [2,4], nums2 = [1,2,3,4]

› Output: [3,-1]

💡 Note: For 2: first greater element to the right is 3. For 4: no element to the right is greater, so -1.

example_3.py — Single Element

$ Input: nums1 = [1], nums2 = [1,2]

› Output: [2]

💡 Note: For 1: first greater element to the right is 2.

Visualization

Tap to expand

Understanding the Visualization

Initialize Stack

Start with an empty stack and empty result map

Process Each Element

For each element in nums2, pop smaller elements from stack and map them to current element

Add Current Element

Push current element onto stack

Handle Remaining

Elements left in stack have no next greater element (-1)

Query Results

Look up each element from nums1 in our result map

Key Takeaway

🎯 Key Insight: The monotonic stack approach transforms an O(n²) problem into O(n) by maintaining elements in decreasing order and efficiently mapping each element to its next greater neighbor.

Time & Space Complexity

Time Complexity

⏱️

O(n*m)

For each of n elements in nums1, we potentially scan all m elements in nums2

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables, no additional data structures

✓ Linear Space

Constraints

1 ≤ nums1.length ≤ nums2.length ≤ 1000
0 ≤ nums1[i], nums2[i] ≤ 10⁴
All integers in nums1 and nums2 are unique
All the integers of nums1 also appear in nums2

Asked in

a Amazon 45 G Google 32 ⊞ Microsoft 28 f Meta 22

The optimal solution uses a monotonic stack to preprocess nums2 and build a HashMap of next greater elements, then looks up results for nums1 in O(n+m) time. The key insight is that the stack maintains elements in decreasing order, and when we find a larger element, it resolves all smaller elements waiting in the stack.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n*m)	O(1)	For each element in nums1, find it in nums2 and scan right for the next greater element
Two-Pass with Stack and HashMap	O(n+m)	O(m)	Use monotonic stack to build next greater elements map, then lookup answers for nums1

Brute Force (Nested Loops) — Algorithm Steps

For each element in nums1, find its position in nums2
From that position, scan rightward in nums2
Return the first element greater than current, or -1 if none exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Element

Locate the current nums1 element in nums2

Scan Right

Look through all elements to the right

Find Greater

Return first greater element or -1

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int* nextGreaterElement(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize) {
    *returnSize = nums1Size;
    int* result = (int*)malloc(nums1Size * sizeof(int));
    
    for (int i = 0; i < nums1Size; i++) {
        int num = nums1[i];
        
        // Find position in nums2
        int pos = -1;
        for (int j = 0; j < nums2Size; j++) {
            if (nums2[j] == num) {
                pos = j;
                break;
            }
        }
        
        // Find next greater element
        result[i] = -1;
        for (int j = pos + 1; j < nums2Size; j++) {
            if (nums2[j] > num) {
                result[i] = nums2[j];
                break;
            }
        }
    }
    
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n*m)

For each of n elements in nums1, we potentially scan all m elements in nums2

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables, no additional data structures

✓ Linear Space

Constraints

1 ≤ nums1.length ≤ nums2.length ≤ 1000
0 ≤ nums1[i], nums2[i] ≤ 10⁴
All integers in nums1 and nums2 are unique
All the integers of nums1 also appear in nums2

85.5K Views

High Frequency

~15 min Avg. Time

2.9K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler