Remove Duplicates from Sorted List - Practice Coding Problems

Remove Duplicates from Sorted List - Problem

Linked List Easy

Given the head of a sorted linked list, your task is to remove all duplicate nodes so that each unique value appears only once in the final list.

Since the linked list is already sorted, all duplicate values will be consecutive, making this problem more manageable than if the duplicates were scattered throughout the list.

Goal: Return the head of the modified linked list with duplicates removed, maintaining the sorted order.

Example: If your linked list is 1 → 1 → 2 → 3 → 3, the result should be 1 → 2 → 3.

This is a fundamental linked list manipulation problem that tests your understanding of pointer manipulation and node traversal - essential skills for any software engineer!

Input & Output

example_1.py — Basic duplicate removal

$ Input: [1,1,2]

› Output: [1,2]

💡 Note: The linked list 1→1→2 has a duplicate value 1. After removing the duplicate, we get 1→2.

example_2.py — Multiple duplicates

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

› Output: [1,2,3]

💡 Note: The linked list has duplicates for both 1 and 3. After removing all duplicates, each unique value appears only once: 1→2→3.

example_3.py — Single node

$ Input: [1]

› Output: [1]

💡 Note: A single node has no duplicates, so the list remains unchanged.

Constraints

The number of nodes in the list is in the range [0, 300]
Each node's value is in the range [-100, 100]
The list is guaranteed to be sorted in non-decreasing order

Visualization

Tap to expand

Understanding the Visualization

Start with sorted cards

Your deck is already sorted: A, A, 2, 3, 3

Compare adjacent cards

Look at current card (A) and next card (A) - they're the same!

Remove the duplicate

Take out the second A and continue with the first A

Continue the process

Now compare A with 2 - different, so move to next position

Handle remaining duplicates

When you reach the 3s, remove the duplicate 3 as well

Final result

Your clean deck: A, 2, 3 - no duplicates!

Key Takeaway

🎯 Key Insight: Since the linked list is sorted, duplicates are always adjacent. This means we only need to compare each node with its immediate neighbor, avoiding the need for nested loops and achieving optimal O(n) time complexity.

Asked in

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

The optimal solution takes advantage of the sorted nature of the linked list by using a single-pass approach. Since duplicates are always adjacent in a sorted list, we only need to compare each node with its immediate neighbor. When duplicates are found, we simply skip over them by updating the next pointer, achieving O(n) time complexity with O(1) space usage.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Optimal Solution	O(n)	O(1)	Traverse the list once, comparing each node with its next node
Brute Force (Nested Iteration)	O(n²)	O(1)	For each node, scan the rest of the list to find and remove all duplicates

One-Pass Optimal Solution — Algorithm Steps

Start from the head of the linked list
While the current node and its next node exist
Compare current node's value with next node's value
If they're equal, skip the next node by updating current.next
If they're different, move to the next node
Return the head of the modified list

Visualization

Tap to expand

Step-by-Step Walkthrough

Compare adjacent nodes

Current (1) compares with next (1) - duplicate found

Skip duplicate

Update current.next to skip the duplicate node

Continue comparison

Compare current (1) with new next (2) - different values

Move forward

Move current pointer to next node and repeat

Code -

solution.c — C

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

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

struct ListNode* deleteDuplicates(struct ListNode* head) {
    if (!head) return head;
    
    struct ListNode* current = head;
    while (current && current->next) {
        if (current->val == current->next->val) {
            // Skip the duplicate node
            struct ListNode* temp = current->next;
            current->next = current->next->next;
            free(temp); // Free memory
        } else {
            // Move to next node only when no duplicate found
            current = current->next;
        }
    }
    
    return head;
}

// Helper functions
struct ListNode* createLinkedList(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 printLinkedList(struct ListNode* head) {
    printf("[");
    struct ListNode* current = head;
    while (current) {
        printf("%d", current->val);
        if (current->next) printf(", ");
        current = current->next;
    }
    printf("]\n");
}

int main() {
    int arr[] = {1, 1, 2, 3, 3}; // Example input
    int size = sizeof(arr) / sizeof(arr[0]);
    struct ListNode* head = createLinkedList(arr, size);
    struct ListNode* result = deleteDuplicates(head);
    printLinkedList(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We traverse the list exactly once, visiting each node at most once

✓ Linear Growth

Space Complexity

O(1)

Only using a constant amount of extra space for the current pointer

✓ Linear Space

85.0K Views

High Frequency

~15 min Avg. Time

2.9K 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 Optimal Solution — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler