Remove Linked List Elements

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

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

✓ Dummy Head Approach (Optimal)

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

This is the optimal approach that uses a dummy head node to simplify the logic. By creating a dummy node that points to the original head, we can treat all node removals uniformly without special handling for head removal. This eliminates edge cases and makes the code cleaner and more maintainable.

Iterative with Special Head Handling

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

This approach handles the removal of nodes by traversing the linked list and maintaining previous and current pointers. When we find a node to remove, we update the previous node's next pointer to skip the current node. The main complexity comes from handling the special case where the head node needs to be removed.

Dummy Head Approach (Optimal) — Algorithm Steps

Create a dummy head node pointing to the original head
Initialize previous pointer to dummy head
Traverse the list starting from the original head
When current node matches val, update prev.next to skip current node
Otherwise, advance the previous pointer
Return dummy.next as the new head

Visualization

Tap to expand

Step-by-Step Walkthrough

Setup Dummy Head

Create dummy node pointing to original head

Initialize Pointers

Set prev = dummy, current = head

Traverse and Remove

Skip nodes with target value, advance prev otherwise

Return Result

Return dummy.next as new head

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) {
    // Create dummy head to simplify logic
    struct ListNode dummy;
    dummy.val = 0;
    dummy.next = head;
    
    struct ListNode* prev = &dummy;
    struct ListNode* current = head;
    
    while (current) {
        if (current->val == val) {
            // Skip the current node
            prev->next = current->next;
            free(current);
            current = prev->next;
        } else {
            // Move prev pointer forward
            prev = current;
            current = current->next;
        }
    }
    
    return dummy.next;
}

// 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 create list from array
struct ListNode* createList(int arr[], int size) {
    if (size == 0) return NULL;
    struct ListNode* head = createNode(arr[0]);
    struct ListNode* current = head;
    for (int i = 1; i < size; i++) {
        current->next = createNode(arr[i]);
        current = current->next;
    }
    return head;
}

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

int main() {
    // Test cases
    int arr1[] = {1, 2, 6, 3, 4, 5, 6};
    struct ListNode* test1 = createList(arr1, 7);
    struct ListNode* result1 = removeElements(test1, 6);
    printList(result1); // 1 2 3 4 5
    
    struct ListNode* test2 = createList(NULL, 0);
    struct ListNode* result2 = removeElements(test2, 1);
    printList(result2); // (empty)
    
    int arr3[] = {7, 7, 7, 7};
    struct ListNode* test3 = createList(arr3, 4);
    struct ListNode* result3 = removeElements(test3, 7);
    printList(result3); // (empty)
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the linked list, visiting each node once

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for the dummy node and 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

Dummy Head Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler