Next Greater Node In Linked List - Practice Coding Problems

Next Greater Node In Linked List - Problem

You're given the head of a singly linked list with n nodes. Your mission is to find the next greater element for each node in the list.

For each node, you need to find the first node that comes after it and has a strictly larger value. If no such node exists, the answer for that position should be 0.

Return an integer array answer where answer[i] represents the value of the next greater node for the i-th node (1-indexed). This is a classic example of the "Next Greater Element" pattern, but with the added challenge of working with a linked list structure.

Example: For linked list 2 → 1 → 5, the answer would be [5, 5, 0] because:

Node 2: Next greater is 5
Node 1: Next greater is 5
Node 5: No next greater element exists

Input & Output

example_1.py — Basic Case

$ Input: head = [2,1,5]

› Output: [5,5,0]

💡 Note: For node with value 2: next greater is 5. For node with value 1: next greater is 5. For node with value 5: no next greater element exists.

example_2.py — Increasing Sequence

$ Input: head = [1,7,5,1,9,2,5,1]

› Output: [7,9,9,9,0,5,0,0]

💡 Note: Each element finds its next greater element or gets 0 if none exists. For example, 7's next greater is 9, 5's next greater is 9, etc.

example_3.py — Single Element

$ Input: head = [5]

› Output: [0]

💡 Note: Single element has no next element, so result is [0].

Constraints

The number of nodes in the linked list is in the range [0, 10⁴]
1 ≤ Node.val ≤ 10⁹
Note: The result should be 1-indexed as per the problem description

Visualization

Tap to expand

Understanding the Visualization

Convert to Array

Transform linked list [2→1→5] into array [2,1,5] for easier processing

Initialize Stack

Create empty stack to store indices of elements waiting for next greater element

Process Elements

For each element, pop smaller elements from stack (they found their answer) and push current index

Handle Remaining

Elements still in stack have no next greater element, so their result stays 0

Key Takeaway

🎯 Key Insight: The monotonic stack pattern allows us to solve "next greater element" problems in O(n) time by maintaining pending queries efficiently and resolving multiple queries when we find a larger element.

Asked in

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

The optimal solution uses a monotonic stack to track indices of elements waiting for their next greater element. As we process each element, we pop all smaller elements from the stack (they found their answer) and push the current index. This achieves O(n) time complexity since each element is pushed and popped exactly once.

Common Approaches

Approach	Time	Space	Notes
✓ Monotonic Stack (Optimal)	O(n)	O(n)	Use a stack to track pending elements waiting for their next greater element
Brute Force (Nested Traversal)	O(n²)	O(n)	For each node, traverse the rest of the list to find the next greater element

Monotonic Stack (Optimal) — Algorithm Steps

Convert linked list to array and initialize result array
Use a stack to store indices of elements waiting for next greater element
For each element, pop from stack all smaller elements and set their result
Push current element's index to stack
Elements remaining in stack have no next greater element

Visualization

Tap to expand

Step-by-Step Walkthrough

Process Element 2

Stack is empty, push index 0. Stack: [0]

Process Element 1

1 < 2, so push index 1. Stack: [0,1]

Process Element 5

5 > 1 and 5 > 2, so pop both indices and set their results. Stack: [2]

Final Result

Result: [5,5,0]. Elements in stack have no next greater element

Code -

solution.c — C

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

struct ListNode {
    int val;
    struct ListNode *next;
};

int* nextLargerNodes(struct ListNode* head, int* returnSize) {
    // Count nodes first
    int count = 0;
    struct ListNode* curr = head;
    while (curr) {
        count++;
        curr = curr->next;
    }
    
    *returnSize = count;
    if (count == 0) return NULL;
    
    // Convert to array
    int* values = (int*)malloc(count * sizeof(int));
    curr = head;
    for (int i = 0; i < count; i++) {
        values[i] = curr->val;
        curr = curr->next;
    }
    
    // Initialize result and stack
    int* result = (int*)calloc(count, sizeof(int));
    int* stack = (int*)malloc(count * sizeof(int));
    int stackSize = 0;
    
    for (int i = 0; i < count; i++) {
        // While stack is not empty and current element is greater
        while (stackSize > 0 && values[i] > values[stack[stackSize - 1]]) {
            int idx = stack[stackSize - 1];
            stackSize--;
            result[idx] = values[i];
        }
        
        stack[stackSize++] = i;
    }
    
    free(values);
    free(stack);
    return result;
}

int main() {
    struct ListNode node3 = {5, NULL};
    struct ListNode node2 = {1, &node3};
    struct ListNode node1 = {2, &node2};
    
    int returnSize;
    int* result = nextLargerNodes(&node1, &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)

Each element is pushed and popped from stack at most once, so total operations are 2n

✓ Linear Growth

Space Complexity

O(n)

Stack can contain at most n elements (in worst case of decreasing sequence)

⚡ Linearithmic Space

63.4K Views

Medium-High Frequency

~18 min Avg. Time

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

Monotonic Stack (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler