Next Greater Element II

Next Greater Element II - Problem

Given a circular integer array nums (i.e., the next element of nums[nums.length - 1] is nums[0]), return the next greater number for every element in nums.

The next greater number of a number x is the first greater number to its traversing-order next in the array, which means you could search circularly to find its next greater number. If it doesn't exist, return -1 for this number.

Input & Output

Example 1 — Basic Circular Array

$ Input: nums = [1,2,1]

› Output: [2,-1,2]

💡 Note: For nums[0]=1, next greater is 2. For nums[1]=2, no greater element exists (-1). For nums[2]=1, wrapping around, next greater is 2.

Example 2 — All Elements Have Next Greater

$ Input: nums = [1,2,3,4,3]

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

💡 Note: nums[0]=1→2, nums[1]=2→3, nums[2]=3→4, nums[3]=4 has no greater (-1), nums[4]=3 wraps to find 4.

Example 3 — Single Element

$ Input: nums = [5]

› Output: [-1]

💡 Note: Only one element, no next greater element possible in circular array.

Constraints

1 ≤ nums.length ≤ 10⁴
-10⁹ ≤ nums[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 M Microsoft 22 f Facebook 18

The key insight is using a monotonic stack to efficiently find next greater elements in a circular array. Best approach is the monotonic stack with double iteration: Time: O(n), Space: O(n).

Common Approaches

✓ Brute Force - Double Loop

⏱️ Time: O(n²) Space: O(1)

For every element, start from the next position and iterate through the array (wrapping around) until we find a greater element or complete the circle.

Monotonic Stack

⏱️ Time: O(n) Space: O(n)

Process the array twice to handle circularity. Use a monotonic decreasing stack to keep track of elements that haven't found their next greater element yet. When we find a greater element, it resolves all smaller elements in the stack.

Brute Force - Double Loop — Algorithm Steps

For each element at index i
Search from (i+1) to (i+n-1) with wraparound using modulo
Return first greater element found, or -1 if none exists

Visualization

Tap to expand

Step-by-Step Walkthrough

For each position

Start from current element

Search circularly

Look ahead with wraparound

Find greater

Return first element > current

Code -

solution.c — C

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

int* solution(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;
        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() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int nums[1000];
    int size = 0;
    char* token = strtok(line + 1, ",]");
    
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int returnSize;
    int* result = solution(nums, size, &returnSize);
    
    // Print result
    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 n elements, we potentially scan n elements in the worst case

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables, no extra data structures

✓ Linear Space

180.0K Views

Medium Frequency

~15 min Avg. Time

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Double Loop — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler