Codestin Search App

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
✓ 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	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) — Algorithm Steps

Convert nums array to hash set for O(1) lookups
Create dummy head to handle edge case where head needs deletion
Use current pointer to traverse the list
For each current.next node, check if value exists in hash set
If found, skip the node by updating current.next
If not found, advance current pointer
Return dummy.next as the new head

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Hash Set

Convert nums [1,2,3] to hash set for instant lookups

Traverse List

Use dummy head and current pointer for clean deletion

Filter Nodes

Skip nodes found in hash set, keep others

Code -

solution.c — C

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

// Hash table implementation
#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) {
    // Build hash set for O(1) lookups
    struct HashTable ht = {0};
    for (int i = 0; i < numsSize; i++) {
        hash_insert(&ht, nums[i]);
    }
    
    // Handle edge case: remove nodes from beginning
    struct ListNode* dummy = (struct ListNode*)malloc(sizeof(struct ListNode));
    dummy->val = 0;
    dummy->next = head;
    struct ListNode* current = dummy;
    
    // Single pass through linked list
    while (current->next) {
        if (hash_contains(&ht, current->next->val)) {
            // Remove node by skipping it
            struct ListNode* temp = current->next;
            current->next = current->next->next;
            free(temp);
        } else {
            // Move to next node
            current = current->next;
        }
    }
    
    struct ListNode* result = dummy->next;
    free(dummy);
    return result;
}

int main() {
    // Simple input parsing for demonstration
    int nums[] = {1, 2, 3};
    int numsSize = 3;
    
    // Create test linked list: 1->2->4->5
    struct ListNode* head = (struct ListNode*)malloc(sizeof(struct ListNode));
    head->val = 1;
    head->next = (struct ListNode*)malloc(sizeof(struct ListNode));
    head->next->val = 2;
    head->next->next = (struct ListNode*)malloc(sizeof(struct ListNode));
    head->next->next->val = 4;
    head->next->next->next = (struct ListNode*)malloc(sizeof(struct ListNode));
    head->next->next->next->val = 5;
    head->next->next->next->next = NULL;
    
    struct ListNode* result = modifiedList(nums, numsSize, head);
    
    // Print result
    printf("[");
    bool first = true;
    while (result) {
        if (!first) printf(",");
        printf("%d", result->val);
        first = false;
        result = result->next;
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

O(m) to build hash set + O(n) to traverse linked list with O(1) lookups per node

✓ Linear Growth

Space Complexity

O(m)

Hash set stores all unique values from nums array, worst case is m elements

✓ 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

One-Pass Hash Set (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler