Next Greater Element II - Practice Coding Problems

Next Greater Element II - Problem

Given a circular integer array nums, your task is to find the next greater element for every element in the array. Think of the array as a circle where the last element connects back to the first element!

The next greater element of a number x is the first number greater than x that appears when you traverse the array in order, searching circularly. If no such greater element exists, return -1 for that position.

Example: For array [1, 2, 1], the next greater elements are [2, -1, 2] because:

For nums[0] = 1: next greater is 2
For nums[1] = 2: no greater element exists, so -1
For nums[2] = 1: searching circularly, we find 2 at index 1

Input & Output

example_1.py — Basic circular array

$ Input: [1, 2, 1]

› Output: [2, -1, 2]

💡 Note: For index 0 (value 1): next greater is 2 at index 1. For index 1 (value 2): no greater element exists. For index 2 (value 1): searching circularly, next greater is 2 at index 1.

example_2.py — All same elements

$ Input: [1, 1, 1, 1]

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

💡 Note: Since all elements are the same, no element has a next greater element, so all results are -1.

example_3.py — Decreasing sequence

$ Input: [5, 4, 3, 2, 1]

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

💡 Note: For index 0 (value 5): no greater element. For all other indices: the next greater element is 5 (wrapping around to index 0).

Visualization

Tap to expand

Understanding the Visualization

Initialize Stack

Start with an empty stack to track indices of unresolved elements

Process Twice

Go through the array twice (2n iterations) to simulate circular nature

Pop and Resolve

When we find a larger element, resolve all smaller pending elements in the stack

Push New Index

Add current index to stack only in first pass to avoid duplicates

Key Takeaway

🎯 Key Insight: The monotonic stack approach efficiently solves the circular next greater element problem by processing the array twice while maintaining a decreasing stack of indices, achieving optimal O(n) time complexity.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of the n elements, we potentially search through all n elements in the worst case

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables, not counting the output array

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁴
-10⁹ ≤ nums[i] ≤ 10⁹
The array is treated as circular

Asked in

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

The optimal solution uses a monotonic decreasing stack with a clever trick: process the array twice to simulate the circular nature. This achieves O(n) time complexity by ensuring each element is pushed and popped at most once, making it much more efficient than the O(n²) brute force approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	For each element, search linearly through the circular array to find the next greater element
Monotonic Stack (Optimal)	O(n)	O(n)	Use a decreasing monotonic stack and process the array twice to handle circularity

Brute Force (Nested Loops) — Algorithm Steps

For each element at index i, start searching from index (i+1) % n
Continue searching circularly until we find an element greater than nums[i]
If we complete a full circle without finding a greater element, return -1
Store the result and move to the next element

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at index 0

Begin searching from position 0, looking for next greater element

Search circularly

Check each subsequent position, wrapping around to beginning

Found or complete circle

Either find greater element or determine none exists

Code -

solution.c — C

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

int* nextGreaterElements(int* nums, int numsSize, int* returnSize) {
    *returnSize = numsSize;
    int* result = (int*)malloc(numsSize * sizeof(int));
    
    for (int i = 0; i < numsSize; i++) {
        result[i] = -1;
        // Search for next greater element starting from next position
        for (int j = 1; j < numsSize; j++) {
            int nextIdx = (i + j) % numsSize;
            if (nums[nextIdx] > nums[i]) {
                result[i] = nums[nextIdx];
                break;
            }
        }
    }
    
    return result;
}

int main() {
    int nums[] = {1, 2, 1};
    int numsSize = 3;
    int returnSize;
    int* result = nextGreaterElements(nums, numsSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of the n elements, we potentially search through all n elements in the worst case

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables, not counting the output array

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁴
-10⁹ ≤ nums[i] ≤ 10⁹
The array is treated as circular

47.0K Views

High Frequency

~15 min Avg. Time

1.6K 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