Remove Nodes From Linked List

Remove Nodes From Linked List - Problem

You are given the head of a linked list. Your task is to remove every node that has a node with a strictly greater value anywhere to the right side of it.

Think of it this way: a node survives if it's the maximum among all nodes from its position to the end of the list. All other nodes should be eliminated!

Example: In the list [5,2,13,3,8], node 5 gets removed because 13 > 5, node 2 gets removed because 13 > 2, node 3 gets removed because 8 > 3. The result is [13,8].

Return the head of the modified linked list.

Input & Output

example_1.py — Standard Case

$ Input: head = [5,2,13,3,8]

› Output: [13,8]

💡 Note: Node 5 is removed because 13 > 5. Node 2 is removed because 13 > 2. Node 3 is removed because 8 > 3. Nodes 13 and 8 have no greater values to their right, so they remain.

example_2.py — Ascending Order

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

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

💡 Note: No node has a strictly greater value to its right (all values are equal), so all nodes remain in the list.

example_3.py — Single Node

$ Input: head = [1]

› Output: [1]

💡 Note: A single node has no nodes to its right, so it always remains in the list.

Constraints

The number of nodes in the list is in the range [1, 10⁵]
1 ≤ Node.val ≤ 10⁵
Follow-up: Can you solve this in O(n) time and O(1) extra space?

Visualization

Tap to expand

Asked in

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

The optimal solution uses a monotonic stack with recursive processing from right to left. By maintaining a decreasing stack of values, we can determine in O(n) time which nodes should survive. The key insight is that a node survives if it's greater than or equal to the maximum value seen from its position to the end of the list.

Common Approaches

✓ Brute Force (Nested Traversal)

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

For every node in the linked list, traverse all nodes to its right to determine if there exists a node with a greater value. If found, mark the current node for removal. This approach requires nested traversals making it inefficient.

Monotonic Stack (Optimal)

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

The key insight is to process the linked list from right to left using recursion or by reversing it. We maintain a monotonic decreasing stack that helps us efficiently determine which nodes should be kept. As we process each node, we pop smaller elements from the stack and decide whether to keep the current node based on the stack's top element.

Brute Force (Nested Traversal) — Algorithm Steps

Start from the head of the linked list
For each node, traverse all remaining nodes to the right
If any right node has a greater value, mark current node for deletion
Remove all marked nodes while maintaining list connections
Return the new head

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Node 5

Node 5 scans right: finds 13 > 5, so mark for removal

Check Node 2

Node 2 scans right: finds 13 > 2, so mark for removal

Check Node 13

Node 13 scans right: no node > 13, so keep it

Check Node 3

Node 3 scans right: finds 8 > 3, so mark for removal

Code -

solution.c — C

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

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

bool hasGreaterRight(struct ListNode* node) {
    struct ListNode* current = node->next;
    while (current) {
        if (current->val > node->val) {
            return true;
        }
        current = current->next;
    }
    return false;
}

struct ListNode* removeNodes(struct ListNode* head) {
    if (!head) return head;
    
    // Create dummy node to handle head removal
    struct ListNode* dummy = (struct ListNode*)malloc(sizeof(struct ListNode));
    dummy->val = 0;
    dummy->next = head;
    struct ListNode* prev = dummy;
    struct ListNode* current = head;
    
    while (current) {
        if (hasGreaterRight(current)) {
            // Remove current node
            prev->next = current->next;
            struct ListNode* temp = current;
            current = current->next;
            free(temp);
        } else {
            prev = current;
            current = current->next;
        }
    }
    
    struct ListNode* newHead = dummy->next;
    free(dummy);
    return newHead;
}

static int values[100000];
static int result[100000];

int main() {
    char line[1000000];
    fgets(line, sizeof(line), stdin);
    
    // Parse comma-separated input
    int count = 0;
    char* p = line;
    while (*p && count < 100000) {
        while (*p == ' ' || *p == '\n') p++;
        if (*p == '\0') break;
        
        values[count] = (int)strtol(p, &p, 10);
        count++;
        
        while (*p == ',') p++;
    }
    
    if (count == 0) {
        printf("[]\n");
        return 0;
    }
    
    // Build linked list
    struct ListNode* head = (struct ListNode*)malloc(sizeof(struct ListNode));
    head->val = values[0];
    head->next = NULL;
    struct ListNode* current = head;
    
    for (int i = 1; i < count; i++) {
        current->next = (struct ListNode*)malloc(sizeof(struct ListNode));
        current = current->next;
        current->val = values[i];
        current->next = NULL;
    }
    
    // Process
    struct ListNode* resultHead = removeNodes(head);
    
    // Output
    int resultCount = 0;
    while (resultHead) {
        result[resultCount++] = resultHead->val;
        struct ListNode* temp = resultHead;
        resultHead = resultHead->next;
        free(temp);
    }
    
    if (resultCount == 1) {
        printf("%d\n", result[0]);
    } else {
        for (int i = 0; i < resultCount; i++) {
            if (i > 0) printf(",");
            printf("%d", result[i]);
        }
        printf("\n");
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we potentially scan all remaining nodes to the right

✓ Linear Growth

Space Complexity

O(1)

Only using a few pointers for traversal, no additional data structures

⚡ Linearithmic Space

42.0K Views

Medium Frequency

~25 min Avg. Time

1.9K 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 (Nested Traversal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler