Remove Duplicates from Sorted List II

Remove Duplicates from Sorted List II - Problem

Given the head of a sorted linked list, delete all nodes that have duplicate numbers, leaving only distinct numbers from the original list. Return the linked list sorted as well.

For example, given 1→2→3→3→4→4→5, return 1→2→5.

Unlike the original "Remove Duplicates" problem which keeps one copy of each duplicate, this problem removes all occurrences of duplicated values completely.

Input & Output

Example 1 — Basic Case with Duplicates

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

› Output: [1,2,5]

💡 Note: Values 3 and 4 appear twice, so remove all occurrences. Keep only unique values 1, 2, and 5.

Example 2 — Head Node is Duplicate

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

› Output: [2,3]

💡 Note: The head node value 1 is duplicated, so both 1's are removed. Only 2 and 3 remain.

Example 3 — All Elements are Duplicates

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

› Output: []

💡 Note: Every value 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]
-100 ≤ Node.val ≤ 100
The list is guaranteed to be sorted in ascending order

Visualization

Tap to expand

Asked in

M Microsoft 45 a Amazon 38 G Google 32 f Facebook 28

The key insight is to use a dummy node to simplify edge cases and detect duplicate sequences in one pass. The optimal approach uses two pointers: when duplicates are found, skip the entire sequence and link around it. Time: O(n), Space: O(1)

Common Approaches

✓ One-Pass with Dummy Head

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

Use a dummy head node to simplify edge cases. Maintain prev and curr pointers to detect and skip all duplicate sequences in one traversal.

Two-Pass Count and Rebuild

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

Traverse the list once to count how many times each value appears. Then traverse again to build a new list containing only nodes with count = 1.

One-Pass with Dummy Head — Algorithm Steps

Step 1: Create dummy node pointing to head
Step 2: Use prev/curr pointers to detect duplicate sequences
Step 3: Skip entire duplicate sequences, link prev to next unique node

Visualization

Tap to expand

Step-by-Step Walkthrough

Setup Pointers

Dummy node points to head, prev tracks last good node

Detect Duplicates

When curr.val == curr.next.val, skip entire sequence

Link Around

Connect prev directly to node after duplicate sequence

Code -

solution.c — C

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

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

struct ListNode* solution(struct ListNode* head) {
    if (!head) return NULL;
    
    // Create dummy node to handle edge cases
    struct ListNode dummy = {0, head};
    struct ListNode* prev = &dummy;
    struct ListNode* curr = head;
    
    while (curr) {
        // Check if current node starts a duplicate sequence
        if (curr->next && curr->val == curr->next->val) {
            // Skip all nodes with this duplicate value
            int duplicateVal = curr->val;
            while (curr && curr->val == duplicateVal) {
                curr = curr->next;
            }
            // Link prev to the node after duplicates
            prev->next = curr;
        } else {
            // No duplicate, move prev pointer
            prev = curr;
            curr = curr->next;
        }
    }
    
    return dummy.next;
}

struct ListNode* arrayToList(int* arr, int size) {
    if (size == 0) return NULL;
    struct ListNode* head = (struct ListNode*)malloc(sizeof(struct ListNode));
    head->val = arr[0];
    head->next = NULL;
    struct ListNode* current = head;
    for (int i = 1; i < size; i++) {
        current->next = (struct ListNode*)malloc(sizeof(struct ListNode));
        current = current->next;
        current->val = arr[i];
        current->next = NULL;
    }
    return head;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int arr[300];
    int size = 0;
    
    // Parse JSON array format
    char* start = strchr(line, '[');
    char* end = strchr(line, ']');
    if (start && end && start < end) {
        start++; // Skip '['
        if (start < end) { // Not empty array
            char* token = strtok(start, ",");
            while (token != NULL && token < end) {
                // Remove any whitespace
                while (*token == ' ') token++;
                if (*token != ']' && *token != '\n' && *token != '\0') {
                    arr[size++] = atoi(token);
                }
                token = strtok(NULL, ",");
            }
        }
    }
    
    struct ListNode* head = arrayToList(arr, size);
    struct ListNode* result = solution(head);
    
    printf("[");
    int first = 1;
    while (result) {
        if (!first) printf(",");
        printf("%d", result->val);
        first = 0;
        result = result->next;
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the linked list of n nodes

✓ Linear Growth

Space Complexity

O(1)

Only uses a few pointer variables, no extra data structures

⚡ Linearithmic Space

187.5K Views

Medium-High Frequency

~25 min Avg. Time

3.4K 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 with Dummy Head — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler