LeetCode //C - 83. Remove Duplicates from Sorted List

83. Remove Duplicates from Sorted List

Given the head of a sorted linked list, delete all duplicates such that each element appears only once. Return the linked list sorted as well.

Example 1:

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

Example 2:

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

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.

From: LeetCode

Link: 83. Remove Duplicates from Sorted List

---

Solution:

Ideas:

1. Check for an Empty List: Before beginning any operations on the linked list, the code checks if the head pointer is NULL. If it is, the function immediately returns NULL, indicating that the list is empty and there are no nodes to process.

2. Traversal with Current Pointer: The function uses a pointer called current to traverse the linked list. This pointer starts at the head of the list.

3. Duplicate Removal Logic: As the list is sorted, all duplicates of an element are adjacent. The current pointer checks the current node (current) against the next node (current->next). If both nodes have the same value (current->val == current->next->val), it means a duplicate is found.

4. Removing the Duplicate Node:

• To remove the duplicate, the link from the current node to the next node is redirected to skip one node, effectively removing the next node from the list (current->next = current->next->next).
• The removed node is then freed using free(), assuming memory management functions are available. This is crucial to prevent memory leaks.

5. Advancement: If no duplicate is found, the current pointer simply moves to the next node in the list (current = current->next).

6. Continuation Until the End: This process is repeated until current or current->next becomes NULL, indicating that the end of the list has been reached or there are no more nodes to compare.

7. Return the Modified List: Finally, the function returns the modified list starting from head. All duplicates have been removed, and the list remains sorted.

Code:

struct ListNode* deleteDuplicates(struct ListNode* head) {
    if (head == NULL) return NULL;

    struct ListNode* current = head;
    while (current->next != NULL) {
        if (current->val == current->next->val) {
            // Remove the duplicate node
            struct ListNode* temp = current->next;
            current->next = temp->next;
            free(temp); // Assuming stdlib.h is included for free()
        } else {
            current = current->next; // Move to the next element if no duplicate
        }
    }
    return head;
}