LeetCode - Remove Duplicates from Sorted List II

Remove Duplicates from Sorted List II

2013.12.26 21:42

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

For example,
Given 1->2->3->3->4->4->5, return 1->2->5.
Given 1->1->1->2->3, return 2->3.

Solution1:

　　This is a variation from the problem "Remove Duplicates from Sorted List". The difference is that you need to remove all nodes with duplicates, instead of removing the duplicates and keeping one in the list.

　　So as to remove the current node, I used an extra pointer pointing to the previous node.

　　This solution is still one-pass, with O(n) time complexity and O(1) space complexity.

Accepted code:

// 1WA, 1AC, I thought there would be more mistakes... excellent
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *deleteDuplicates(ListNode *head) {
        // IMPORTANT: Please reset any member data you declared, as
        // the same Solution instance will be reused for each test case.
        bool dup;
        
        if(head == nullptr){
            return head;
        }
        
        ListNode *root;
        
        root = new ListNode(0);
        root->next = head;
        ListNode *ptr = head;
        ListNode *tmp;
        ListNode *par = root;
        
        // 1WA here, initialization for $dup missing
        dup = false;
        while(ptr != nullptr){
            if(ptr->next != nullptr){
                if(ptr->val == ptr->next->val){
                    if(!dup){
                        dup = true;
                    }
                    tmp = ptr->next;
                    ptr->next = tmp->next;
                    delete tmp;
                }else{
                    if(dup){
                        par->next = ptr->next;
                        delete ptr;
                        ptr = par->next;
                        dup = false;
                    }else{
                        par = par->next;
                        ptr = par->next;
                    }
                }
            }else{
                if(dup){
                    par->next = ptr->next;
                    delete ptr;
                    ptr = par->next;
                    dup = false;
                }else{
                    par = par->next;
                    ptr = par->next;
                }
            }
        }
        
        head = root->next;
        delete root;
        
        return head;
    }
};

Solution2:

　　The previous solution has one new operation. It's better to avoid it with some extra code, if this function would be called frequently.

　　If the head node has duplicates, we'll remove the leading duplicates and find a new head nodes first. The latter part is similar to the solution given above.

　　It's still a one-pass algorithm with O(n) time complexity and O(1) space complexity.

Accepted code:

// 1RE, 1AC, could've been perfect with more patience.
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *deleteDuplicates(ListNode *head) {
        // IMPORTANT: Please reset any member data you declared, as
        // the same Solution instance will be reused for each test case.
        if(head == nullptr){
            return head;
        }
        
        int tmp_val = 0;
        ListNode *par = nullptr, *ptr = nullptr;
        // remove all head duplicates first
        // 1RE here, {1} would result in $par uninitialized.
        par = head;
        while(head != nullptr && head->next != nullptr){
            if(head->val == head->next->val){
                // head node has duplicates
                tmp_val = head->val;
                while(head != nullptr && head->val == tmp_val){
                    ptr = head;
                    head = head->next;
                    delete ptr;
                }
            }else{
                par = head;
                break;
            }
        }
        
        ListNode *ptr2 = nullptr;
        ptr = par->next;
        while(ptr != nullptr && ptr->next != nullptr){
            if(ptr->val == ptr->next->val){
                tmp_val = ptr->val;
                while(ptr != nullptr && ptr->val == tmp_val){
                    ptr2 = ptr;
                    ptr = ptr->next;
                    delete ptr2;
                }
                par->next = ptr;
            }else{
                par = ptr;
                ptr = ptr->next;
            }
        }
        
        return head;
    }
};