Next Greater Element IV

Next Greater Element IV - Problem

Array Binary Search Stack Sorting Heap (Priority Queue) Monotonic Stack Hard

You are given a 0-indexed array of non-negative integers nums. For each integer in nums, you must find its respective second greater integer.

The second greater integer of nums[i] is nums[j] such that:

j > i
nums[j] > nums[i]
There exists exactly one index k such that nums[k] > nums[i] and i < k < j.

If there is no such nums[j], the second greater integer is considered to be -1.

For example, in the array [1, 2, 4, 3], the second greater integer of 1 is 4, 2 is 3, and that of 3 and 4 is -1.

Return an integer array answer, where answer[i] is the second greater integer of nums[i].

Input & Output

Example 1 — Basic Case

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

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

💡 Note: For 1: greater elements are 2,4,3 → second greater is 4. For 2: greater elements are 4,3 → second greater is 3. For 4 and 3: no second greater element exists.

Example 2 — All Decreasing

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

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

💡 Note: In a decreasing array, no element has a greater element to its right, so all results are -1.

Example 3 — All Increasing

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

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

💡 Note: For 1: greater are 2,3,4,5 → second is 3. For 2: greater are 3,4,5 → second is 4. For 3: greater are 4,5 → second is 5.

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Facebook 6

The key insight is to use two monotonic stacks to efficiently track the first and second greater elements. The optimal approach uses two stacks to process elements in O(n) time. Time: O(n), Space: O(n)

Common Approaches

✓ Brute Force

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

For each position i, iterate through all positions j > i, count elements greater than nums[i], and return the second one found.

Two Monotonic Stacks

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

Maintain a monotonic decreasing stack to find next greater elements, and a second stack to track elements waiting for their second greater element.

Brute Force — Algorithm Steps

Step 1: For each element at index i
Step 2: Scan all elements to the right
Step 3: Count greater elements until we find the second one

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at index i

Begin scanning from current position

Count greater elements

Count elements > nums[i] to the right

Find second

Return the second greater element found

Code -

solution.c — C

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

void solution(int* nums, int numsSize, int* result) {
    for (int i = 0; i < numsSize; i++) {
        result[i] = -1;
        for (int j = i + 1; j < numsSize; j++) {
            if (nums[j] > nums[i]) {
                // Count elements greater than nums[i] between i and j
                int count = 0;
                for (int k = i + 1; k < j; k++) {
                    if (nums[k] > nums[i]) {
                        count++;
                    }
                }
                // If exactly one greater element exists between i and j
                if (count == 1) {
                    result[i] = nums[j];
                    break;
                }
            }
        }
    }
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int nums[1000];
    int result[1000];
    int size = 0;
    
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != '\n') {
            nums[size++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    solution(nums, size, result);
    
    printf("[");
    for (int i = 0; i < size; i++) {
        printf("%d", result[i]);
        if (i < size - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops - outer loop n times, inner loop up to n times

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables, no extra data structures

⚡ Linearithmic Space

24.5K Views

Medium Frequency

~35 min Avg. Time

892 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler