Remove Duplicates From an Unsorted Linked List

Remove Duplicates From an Unsorted Linked List - Problem

You're given the head of a linked list that contains duplicate values scattered throughout. Your task is to completely remove all nodes that have values appearing more than once in the list.

🎯 Goal: If a value appears multiple times anywhere in the linked list, remove all nodes with that value - not just the duplicates!

Example: In the linked list 1 → 2 → 3 → 2 → 4, the value 2 appears twice, so we must remove both nodes containing 2, leaving us with 1 → 3 → 4.

This problem is trickier than standard duplicate removal because:

The linked list is unsorted, so duplicates can be anywhere
We must remove all instances of duplicate values, not just extras
We need to preserve the original order of remaining elements

Input & Output

example_1.py — Basic Case

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

› Output: [1,3]

💡 Note: The value 2 appears twice (at positions 1 and 3), so we remove both nodes containing 2. The remaining nodes are 1 and 3, preserving their original order.

example_2.py — Multiple Duplicates

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

› Output: []

💡 Note: Both values 1 and 2 appear twice in the list. Since every value is duplicated, we must remove all nodes, resulting in an empty list.

example_3.py — No Duplicates

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

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

💡 Note: Each value appears exactly once, so no nodes need to be removed. The entire original list is returned unchanged.

Constraints

The number of nodes in the given list is in the range [1, 10⁵]
Each node's value is in the range [1, 10⁵]
Follow-up: Can you solve this problem in one pass?

Visualization

Tap to expand

Understanding the Visualization

Inventory Pass

Walk the entire assembly line with a clipboard, recording how many times each model number appears

Quality Check

Mark any model numbers that appear more than once as 'defective batch'

Removal Pass

Walk the line again, removing ALL products whose model numbers were marked as defective

Final Result

Only products with unique model numbers remain on the assembly line

Key Takeaway

🎯 Key Insight: We need to identify ALL occurrences of duplicate values and remove them entirely, not just the extras. The two-pass approach efficiently handles this by first counting frequencies, then filtering based on those counts.

Asked in

G Google 35 a Amazon 28 ⊞ Microsoft 22 f Meta 18

The optimal approach uses a two-pass hash table strategy. First pass counts the frequency of each value in O(n) time. Second pass removes all nodes whose values appear more than once. This gives us O(n) time complexity and O(n) space complexity, which is much better than the brute force O(n²) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	For each node, traverse the entire list to count occurrences, then remove nodes with duplicate values
Two-Pass Hash Table	O(n)	O(n)	First pass counts frequencies, second pass removes nodes with duplicate values

Brute Force (Nested Loops) — Algorithm Steps

Traverse the linked list to count frequency of each value
For each unique value that appears more than once, traverse the list again to remove all nodes with that value
Use a dummy head to handle edge cases where the first node needs to be removed
Maintain proper linking while removing nodes

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at first node

Begin with the head of the linked list

Count occurrences

For current node's value, traverse entire list counting matches

Mark for removal

If count > 1, mark all nodes with this value for deletion

Move to next unique value

Continue with next node that has different value

Code -

solution.c — C

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

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

int countValue(struct ListNode* head, int targetVal) {
    int count = 0;
    struct ListNode* curr = head;
    while (curr) {
        if (curr->val == targetVal) {
            count++;
        }
        curr = curr->next;
    }
    return count;
}

struct ListNode* deleteDuplicatesUnsorted(struct ListNode* head) {
    if (!head) return NULL;
    
    struct ListNode dummy;
    dummy.val = 0;
    dummy.next = head;
    struct ListNode* prev = &dummy;
    struct ListNode* curr = head;
    
    while (curr) {
        int freq = countValue(head, curr->val);
        
        if (freq > 1) {
            int valToRemove = curr->val;
            while (curr && curr->val == valToRemove) {
                prev->next = curr->next;
                struct ListNode* temp = curr;
                curr = curr->next;
                free(temp);
            }
        } else {
            prev = curr;
            curr = curr->next;
        }
    }
    
    return dummy.next;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we potentially traverse the entire list to count occurrences

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a constant amount of extra space for pointers

✓ Linear Space

23.4K Views

Medium Frequency

~15 min Avg. Time

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

Visualization

Code -

Time & Space Complexity

Select Compiler