Next Greater Element IV - Practice Coding Problems

Next Greater Element IV - Problem

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

Given an array of non-negative integers, your task is to find the second greater element for each number in the array.

The second greater element of nums[i] is the first element to the right that is greater than nums[i], but with exactly one greater element between them.

More formally, nums[j] is the second greater element of nums[i] if:

j > i (appears after the current element)
nums[j] > nums[i] (is greater than current element)
There exists exactly one index k where i < k < j and nums[k] > nums[i]

If no such element exists, return -1 for that position.

Example: In array [1, 2, 4, 3], the second greater element of 1 is 4 (with 2 as the first greater), and for 2 it's 3 (with 4 as the first greater).

Input & Output

example_1.py — Basic case

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

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

💡 Note: For 1: first greater is 2, second greater is 4. For 2: first greater is 4, second greater is 3. For 4 and 3: no second greater elements exist.

example_2.py — Increasing sequence

$ Input: [2, 4, 0, 9, 6]

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

💡 Note: For 2: first greater is 4, second greater is 9. For 4: first greater is 9, second greater is 6. For 0: first greater is 2, second greater is 9.

example_3.py — Edge case with duplicates

$ Input: [3, 3]

› Output: [-1, -1]

💡 Note: No element has a second greater element since we need strictly greater elements and there are only duplicates.

Visualization

Tap to expand

Understanding the Visualization

Arrival of New Hiker

A new hiker (element) arrives at the trail

Check Second Peak Seekers

Check if this hiker's position can serve as the second peak for anyone in the second group

Promote First Peak Finders

Move hikers from first group to second group if current position is their first peak

Add to First Group

Add the new hiker to the first group to search for their first peak

Key Takeaway

🎯 Key Insight: By managing two separate groups (stacks) of elements based on their progress toward finding greater elements, we can efficiently solve the problem in a single pass with optimal time complexity.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array, each element is pushed and popped from stacks at most once

✓ Linear Growth

Space Complexity

O(n)

Space for result array and two monotonic stacks, each can hold at most n elements

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁴
0 ≤ nums[i] ≤ 10⁹
Follow up: Could you find an O(n) time solution?

Asked in

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

The optimal solution uses two monotonic stacks in a single pass: one for elements waiting for their first greater element, and another for elements waiting for their second greater element. This achieves O(n) time complexity with elegant stack management that processes each element exactly once.

Common Approaches

Approach	Time	Space	Notes
✓ Optimal Two-Stack Solution	O(n)	O(n)	Use two stacks simultaneously to track first and second greater elements in one pass
Brute Force (Triple Nested Loops)	O(n³)	O(1)	Check all possible combinations of i, k, j to find second greater elements
Two-Pass with Stack Optimization	O(n)	O(n)	Use monotonic stack to find first greater elements, then find second greater elements

Optimal Two-Stack Solution — Algorithm Steps

Initialize two stacks: one for first greater elements, one for second greater elements
For each element in the array, first check if it can be the second greater element for any element in the second stack
Pop elements from the second stack if current element is greater - these found their second greater element
Move elements from first stack to second stack if current element is their first greater element
Add current element to the first stack as it waits for its first greater element
Continue until all elements are processed

Visualization

Tap to expand

Step-by-Step Walkthrough

Process Current Element

Check if current element can serve as second greater for any element

Update Second Stack

Pop elements from second stack if current element is their second greater

Move Elements

Move elements from first stack to second stack if current is their first greater

Add to First Stack

Add current element to first stack to wait for its first greater element

Code -

solution.c — C

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

int* secondGreaterElement(int* nums, int numsSize, int* returnSize) {
    *returnSize = numsSize;
    int* result = (int*)malloc(numsSize * sizeof(int));
    int* firstStack = (int*)malloc(numsSize * sizeof(int));
    int* secondStack = (int*)malloc(numsSize * sizeof(int));
    int* temp = (int*)malloc(numsSize * sizeof(int));
    
    for (int i = 0; i < numsSize; i++) {
        result[i] = -1;
    }
    
    int firstTop = -1, secondTop = -1;
    
    for (int i = 0; i < numsSize; i++) {
        // Check if current element is second greater for elements in secondStack
        while (secondTop >= 0 && nums[i] > nums[secondStack[secondTop]]) {
            int idx = secondStack[secondTop--];
            result[idx] = nums[i];
        }
        
        // Move elements from firstStack to secondStack if current is their first greater
        int tempTop = -1;
        while (firstTop >= 0 && nums[i] > nums[firstStack[firstTop]]) {
            temp[++tempTop] = firstStack[firstTop--];
        }
        
        // Add moved elements to secondStack (they found their first greater)
        while (tempTop >= 0) {
            secondStack[++secondTop] = temp[tempTop--];
        }
        
        // Current element is waiting for its first greater
        firstStack[++firstTop] = i;
    }
    
    free(firstStack);
    free(secondStack);
    free(temp);
    return result;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    // Parse input array
    int nums[1000];
    int size = 0;
    char* token = strtok(input, "[],\n ");
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    int returnSize;
    int* result = secondGreaterElement(nums, size, &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)

Single pass through array, each element is pushed and popped from stacks at most once

✓ Linear Growth

Space Complexity

O(n)

Space for result array and two monotonic stacks, each can hold at most n elements

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁴
0 ≤ nums[i] ≤ 10⁹
Follow up: Could you find an O(n) time solution?

47.2K Views

High Frequency

~25 min Avg. Time

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

Optimal Two-Stack Solution — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler