Remove Linked List Elements - Practice Coding Problems

Remove Linked List Elements - Problem

You're given the head of a linked list and an integer val. Your task is to remove all nodes from the linked list that contain the value val, and return the new head of the modified list.

This is a classic linked list manipulation problem that tests your understanding of pointer management and edge case handling. You'll need to consider scenarios like removing the head node, removing consecutive nodes, or even removing all nodes from the list.

Key Challenge: The tricky part is handling cases where the head node itself needs to be removed, which requires careful pointer manipulation to avoid losing the reference to the new list.

Input & Output

example_1.py — Remove Middle Elements

$ Input: head = [1,2,6,3,4,5,6], val = 6

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

💡 Note: The nodes with value 6 are at positions 2 and 6 (0-indexed). After removing these nodes, the remaining list becomes [1,2,3,4,5].

example_2.py — Empty List

$ Input: head = [], val = 1

› Output: []

💡 Note: The input list is already empty, so removing any value results in an empty list.

example_3.py — Remove All Elements

$ Input: head = [7,7,7,7], val = 7

› Output: []

💡 Note: All nodes in the list have the value 7, so removing all occurrences of 7 results in an empty list.

Constraints

The number of nodes in the list is in the range [0, 10⁴]
-50 ≤ Node.val ≤ 50
0 ≤ val ≤ 50

Visualization

Tap to expand

Understanding the Visualization

Station Setup

Place a dummy engine at the front to simplify operations

Inspection Walk

Walk along the train checking each car's cargo

Car Removal

When finding target cargo, disconnect that car and relink neighbors

Final Assembly

Return the train starting from the first real car

Key Takeaway

🎯 Key Insight: Using a dummy head eliminates the complexity of special case handling, making the removal process uniform for all nodes including the original head.

Asked in

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

The optimal solution uses a dummy head node to eliminate special case handling. By creating a dummy node that points to the original head, we can treat all node removals uniformly with O(n) time and O(1) space complexity. The key insight is that the dummy head simplifies pointer management and makes the code more maintainable.

Common Approaches

Approach	Time	Space	Notes
✓ Iterative with Special Head Handling	O(n)	O(1)	Traverse the list and remove matching nodes with special handling for head removal
Dummy Head Approach (Optimal)	O(n)	O(1)	Use a dummy head node to eliminate special case handling and traverse once

Iterative with Special Head Handling — Algorithm Steps

Handle head removal: Keep removing head nodes that match val until we find a valid head
Initialize previous pointer to track the node before current
Traverse the list starting from the new head
When current node matches val, update prev.next to skip current node
Otherwise, advance the previous pointer
Return the final head

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Original list: 1→2→6→3→4→5→6, target value: 6

Check Head

Head value (1) ≠ 6, so keep head and start traversal

Find First Match

Found node with value 6, update previous node to skip it

Continue Traversal

Continue checking remaining nodes

Find Second Match

Found another node with value 6 at the end, remove it

Final Result

Return modified list: 1→2→3→4→5

Code -

solution.c — C

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

// Definition for singly-linked list.
struct ListNode {
    int val;
    struct ListNode *next;
};

struct ListNode* removeElements(struct ListNode* head, int val) {
    // Remove all head nodes that match val
    while (head && head->val == val) {
        struct ListNode* temp = head;
        head = head->next;
        free(temp);
    }
    
    // If list becomes empty
    if (!head) {
        return NULL;
    }
    
    // Remove remaining matching nodes
    struct ListNode* prev = head;
    struct ListNode* current = head->next;
    
    while (current) {
        if (current->val == val) {
            prev->next = current->next;
            free(current);
            current = prev->next;
        } else {
            prev = current;
            current = current->next;
        }
    }
    
    return head;
}

// Helper function to create a new node
struct ListNode* createNode(int val) {
    struct ListNode* node = (struct ListNode*)malloc(sizeof(struct ListNode));
    node->val = val;
    node->next = NULL;
    return node;
}

// Helper function to print list
void printList(struct ListNode* head) {
    while (head) {
        printf("%d ", head->val);
        head = head->next;
    }
    printf("\n");
}

int main() {
    // Create test list: [1, 2, 6, 3, 4, 5, 6]
    struct ListNode* head = createNode(1);
    head->next = createNode(2);
    head->next->next = createNode(6);
    head->next->next->next = createNode(3);
    head->next->next->next->next = createNode(4);
    head->next->next->next->next->next = createNode(5);
    head->next->next->next->next->next->next = createNode(6);
    
    struct ListNode* result = removeElements(head, 6);
    printList(result); // Output: 1 2 3 4 5
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We traverse the linked list once, visiting each node exactly once

✓ Linear Growth

Space Complexity

O(1)

Only using a constant amount of extra space for pointers

✓ Linear Space

82.2K Views

High Frequency

~15 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

Iterative with Special Head Handling — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler