Remove Duplicates from Sorted List II - Practice Coding Problems

Remove Duplicates from Sorted List II - Problem

You are given the head of a sorted linked list. Your task is to remove all nodes that have duplicate numbers, leaving only the nodes that appear exactly once in the original list.

Unlike the classic "remove duplicates" problem where you keep one copy of each duplicate, here you must completely eliminate all nodes that appear more than once.

Example: If your list contains [1,2,3,3,4,4,5], the result should be [1,2,5] because 3 and 4 appeared multiple times and must be completely removed.

Return the head of the modified linked list, which should remain sorted.

Input & Output

example_1.py — Basic case with duplicates

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

› Output: [1,2,5]

💡 Note: Numbers 3 and 4 appear more than once, so they are completely removed. Only 1, 2, and 5 appear exactly once.

example_2.py — All duplicates

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

› Output: [2,3]

💡 Note: Number 1 appears three times, so all occurrences are removed. Numbers 2 and 3 appear exactly once.

example_3.py — Edge case - all nodes are duplicates

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

› Output: []

💡 Note: Every number appears exactly twice, so all nodes are removed, resulting in an empty list.

Constraints

The number of nodes in the list is in the range [0, 300]
Node values are in the range [-100, 100]
The list is guaranteed to be sorted in ascending order

Visualization

Tap to expand

Understanding the Visualization

Set Up Security

Place a security checkpoint (dummy head) before the guest list

Check Each Guest

Scan through the list looking for duplicate names

Remove Entire Groups

When duplicates found, remove ALL instances of that name

Keep Unique Guests

Only guests with unique names get to stay on the VIP list

Key Takeaway

🎯 Key Insight: Use a dummy head node and maintain a previous pointer to safely skip entire groups of duplicates in one pass, leveraging the sorted property for optimal O(n) performance.

Asked in

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

The optimal approach uses a dummy head node and two pointers (previous and current) to efficiently remove duplicate groups in a single pass. When duplicates are detected, we skip the entire group and directly link the previous node to the next unique node, achieving O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Hash Table	O(n)	O(n)	First pass counts occurrences, second pass builds result
Two Pointers with Dummy Head (Optimal)	O(n)	O(1)	Use dummy head and previous/current pointers to skip duplicate groups in one pass
Brute Force (Nested Traversal)	O(n²)	O(n)	For each node, traverse the entire list to check for duplicates

Two-Pass Hash Table — Algorithm Steps

First pass: traverse the linked list and count occurrences of each value in a hash table
Second pass: traverse the list again and build new list with only values that have count = 1
Use a dummy head to simplify edge cases
Return the next node of dummy head as the result

Visualization

Tap to expand

Step-by-Step Walkthrough

First Pass - Count

Traverse list once to count occurrences: {1:1, 2:1, 3:2, 4:2, 5:1}

Second Pass - Filter

Traverse again, only include values with count=1

Build Result

Create new linked list with unique values: 1→2→5

Code -

solution.c — C

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

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

// Simple hash table for counting
#define HASH_SIZE 1000
struct HashNode {
    int key;
    int count;
    struct HashNode* next;
};

struct HashNode* hashTable[HASH_SIZE];

int hash(int key) {
    return abs(key) % HASH_SIZE;
}

void insertOrIncrement(int key) {
    int index = hash(key);
    struct HashNode* curr = hashTable[index];
    
    while (curr) {
        if (curr->key == key) {
            curr->count++;
            return;
        }
        curr = curr->next;
    }
    
    struct HashNode* newNode = (struct HashNode*)malloc(sizeof(struct HashNode));
    newNode->key = key;
    newNode->count = 1;
    newNode->next = hashTable[index];
    hashTable[index] = newNode;
}

int getCount(int key) {
    int index = hash(key);
    struct HashNode* curr = hashTable[index];
    
    while (curr) {
        if (curr->key == key) {
            return curr->count;
        }
        curr = curr->next;
    }
    return 0;
}

struct ListNode* deleteDuplicates(struct ListNode* head) {
    if (!head) return NULL;
    
    // Initialize hash table
    for (int i = 0; i < HASH_SIZE; i++) {
        hashTable[i] = NULL;
    }
    
    // First pass: count occurrences
    struct ListNode* curr = head;
    while (curr) {
        insertOrIncrement(curr->val);
        curr = curr->next;
    }
    
    // Second pass: build result with unique values only
    struct ListNode* dummy = (struct ListNode*)malloc(sizeof(struct ListNode));
    dummy->val = 0;
    dummy->next = NULL;
    
    struct ListNode* prev = dummy;
    curr = head;
    
    while (curr) {
        if (getCount(curr->val) == 1) {
            prev->next = (struct ListNode*)malloc(sizeof(struct ListNode));
            prev->next->val = curr->val;
            prev->next->next = NULL;
            prev = prev->next;
        }
        curr = curr->next;
    }
    
    return dummy->next;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two passes through the list: O(n) + O(n) = O(n)

✓ Linear Growth

Space Complexity

O(n)

Hash table stores at most n unique values

⚡ Linearithmic Space

52.4K Views

High Frequency

~18 min Avg. Time

1.5K 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 Table — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler