Delete Nodes From Linked List Present in Array

Delete Nodes From Linked List Present in Array - Problem

You're given an array of integers nums containing values that need to be filtered out from a linked list. Your task is to traverse the linked list and remove all nodes whose values appear anywhere in the nums array.

Think of it as having a blacklist of values - any node in the linked list matching a value from this blacklist should be deleted. The challenge is to do this efficiently while maintaining the structure of the remaining linked list.

Goal: Return the head of the modified linked list after removing all blacklisted nodes.

Input: An array nums and the head of a singly linked list

Output: The head of the filtered linked list

Input & Output

example_1.py — Basic Filtering

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

› Output: [4,5]

💡 Note: Remove nodes with values 1, 2, and 3 from the linked list, leaving only nodes 4 and 5

example_2.py — Remove All Nodes

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

› Output: []

💡 Note: All nodes have value 1 which exists in nums, so the entire list is removed

example_3.py — Remove None

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

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

💡 Note: None of the list values (1,2,3,4) appear in nums [5], so all nodes are kept

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁵
The number of nodes in the given list is in the range [1, 10⁵]
1 ≤ Node.val ≤ 10⁵
The input is generated such that there is at least one node in the linked list that has a value not present in nums

Visualization

Tap to expand

Understanding the Visualization

Memorize Blacklist

Security guard studies the blacklist and memorizes all banned individuals (build hash set)

Process Queue

As people walk through, guard instantly recognizes blacklisted individuals and removes them

Maintain Order

Non-blacklisted people continue through in their original order

Key Takeaway

🎯 Key Insight: Converting the blacklist to a hash set transforms slow O(n) searches into instant O(1) lookups, making the entire filtering process much more efficient!

Asked in

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

The optimal solution uses a hash set to convert the nums array into a data structure that supports O(1) lookups. We then traverse the linked list once, using a dummy head to handle edge cases, and remove any nodes whose values exist in the hash set. This achieves O(n + m) time complexity and is the most efficient approach for this problem.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Hash Set	O(n + m)	O(m)	Build hash set from nums array, then traverse linked list with O(1) lookups
Brute Force (Linear Search)	O(n×m)	O(1)	For each node, search the entire nums array to check if it should be deleted
One-Pass Hash Set (Optimal)	O(n + m)	O(m)	Build hash set first, then traverse linked list once - most efficient approach

Two-Pass Hash Set — Algorithm Steps

Convert nums array to a hash set for O(1) lookup time
Create a dummy head to simplify edge case handling
Traverse the linked list with current and current.next pointers
For each node, check if its value exists in the hash set
If found, remove the node by adjusting pointers
Return the new head of the modified list

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Hash Set

Convert nums array [3,1,2] to hash set for O(1) lookups

Check Node 1

Look up value 1 in hash set - found! Delete node

Check Node 2

Look up value 2 in hash set - found! Delete node

Code -

solution.c — C

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

// Simple hash table for integers
#define HASH_SIZE 10007

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

struct HashTable {
    struct HashNode* buckets[HASH_SIZE];
};

int hash_func(int val) {
    return abs(val) % HASH_SIZE;
}

void hash_insert(struct HashTable* ht, int val) {
    int index = hash_func(val);
    struct HashNode* node = (struct HashNode*)malloc(sizeof(struct HashNode));
    node->val = val;
    node->next = ht->buckets[index];
    ht->buckets[index] = node;
}

bool hash_contains(struct HashTable* ht, int val) {
    int index = hash_func(val);
    struct HashNode* current = ht->buckets[index];
    while (current) {
        if (current->val == val) return true;
        current = current->next;
    }
    return false;
}

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

struct ListNode* modifiedList(int* nums, int numsSize, struct ListNode* head) {
    // First pass: build hash table from nums
    struct HashTable ht = {0};
    for (int i = 0; i < numsSize; i++) {
        hash_insert(&ht, nums[i]);
    }
    
    // Create dummy head to handle edge cases
    struct ListNode* dummy = (struct ListNode*)malloc(sizeof(struct ListNode));
    dummy->val = 0;
    dummy->next = head;
    struct ListNode* current = dummy;
    
    // Second pass: traverse linked list and remove nodes
    while (current->next) {
        if (hash_contains(&ht, current->next->val)) {  // O(1) average lookup
            struct ListNode* temp = current->next;
            current->next = current->next->next;
            free(temp);
        } else {
            current = current->next;
        }
    }
    
    struct ListNode* result = dummy->next;
    free(dummy);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

O(m) to build hash set from nums array, then O(n) to traverse linked list with O(1) lookups

✓ Linear Growth

Space Complexity

O(m)

Hash set stores up to m unique values from nums array

✓ Linear Space

42.5K Views

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

Two-Pass Hash Set — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler