Codestin Search App

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
✓ 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	O(n)	O(1)	Traverse the list once, comparing each node with its next node

Brute Force (Nested Iteration) — Algorithm Steps

Start from the head of the linked list
For each current node, traverse all remaining nodes
Remove any node that has the same value as the current node
Continue until we've processed all nodes
Return the modified list

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first node

Current node (1) checks all following nodes

Find and remove duplicates

Remove the second occurrence of 1

Move to next unique node

Move to node 2 and repeat the process

Continue until end

Process all nodes in the same manner

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) {
        // For each node, remove all duplicates in the rest of the list
        struct ListNode* runner = current;
        while (runner->next) {
            if (runner->next->val == current->val) {
                struct ListNode* temp = runner->next;
                runner->next = runner->next->next; // Remove duplicate
                free(temp);
            } else {
                runner = runner->next;
            }
        }
        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²)

For each of n nodes, we potentially check all remaining nodes, leading to n + (n-1) + (n-2) + ... + 1 = n(n+1)/2 operations

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a constant amount of extra space for pointers

✓ 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

Brute Force (Nested Iteration) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler