剑指18-2. 删除链表中重复的节点 && LeetCode 82. Remove Duplicates from Sorted List II

题目：

在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5

LeetCode版：

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

Example 1:

Input: 1->2->3->3->4->4->5
Output: 1->2->5

Example 2:

Input: 1->1->1->2->3
Output: 2->3

---

这道题和Remove Duplicates from Sorted List I的区别就在于，I中只需要删除后面与前面重复的节点（留一个），而II中需要删除重复的数字的所有节点（一个也不留）。

首先还是按照常规的思路来考虑，这次比上次做I就稍微熟练一些了，能很快地想到需要设置一个prev来存放待删除的节点的前一个节点，设置一个curr来遍历整个链表。在遍历的过程中，刚开始有点倾向于像I一样通过while循环来判断，但是感觉搞来搞去太复杂了就偷看了剑指和讨论版，发现一种方法是直接设置了一个bool变量来确定是否需要删除。这个刚开始我也想过，因为如果要设置prev的话，应该在找到相同数字之前设置好，不然prev还是最开始初始化的NULL，这样设了bool变量以后分情况处理就变得简单明了了：如果不需要删除，就设置一下prev；如果需要删除，就开始找有多少个需要删除的节点，并把prev->next连接到最后一个需要删除的节点的下一个节点，最后也不要忘了把curr移向下一个位置（第一次写完代码运行出来才发现忘了加）。运行时间8ms，打败100%，空间8.9M，打败97.09%：

/**
 * 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) {
        if (head == NULL) {
            return NULL;
        }
        ListNode* curr = head;
        ListNode* prev = NULL;
        while (curr) {
            bool delete_flag = false;
            if (curr->next && curr->val == curr->next->val) {
                delete_flag = true;
            }
            
            if (!delete_flag) {
                prev = curr;
                curr = curr->next;
            }
            else {
                curr = curr->next;
                while (curr->next && curr->val == curr->next->val) {
                    curr = curr->next;
                }
                if (prev == NULL) {
                    head = curr->next;
                }
                else {
                    prev->next = curr->next;
                }
                curr = curr->next;
            }
        }
        return head;
    }
};

接下来整理一下讨论版看到的其他大佬们的奇妙操作：

1. 递归版本

这个递归的参数是头节点，每次递归就递归删除当前头节点后面的部分。递归基：当head为NULL时，直接返回NULL，或head已经是尾节点时，返回它自己（head）。每次递归的过程中，如果当前节点和下个节点不同，则以当前head的下个节点为参数来递归调用这个函数，并把函数返回值赋值给当前head的next（相当于当前head后面接的是递归回来的后面部分），最后需要return head（这个return还没完全搞懂）；如果当前节点和下个节点相同，则说明出现了重复，我们找到下一个不同的节点，并以它为参数进行下一次递归，需要return递归函数的值（return又双叒没搞定）。时间12ms，59.06；空间9.1M，48.54%。如果递归还是时间和空间效率都不如普通的迭代啊。

/**
 * 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) {
        if (head == NULL) {
            return NULL;
        }
        else if (head->next == NULL) {
            return head;
        }
        
        ListNode* curr;
        if (head->val != head->next->val) {
            curr = head->next;
            head->next = deleteDuplicates(curr);
            return head;
        }
        else {
            curr = head->next->next;
            while (curr && curr->val == head->val) {
                curr = curr->next;
            };
            return deleteDuplicates(curr);
        }
    }
};

2. 通过自制新的头节点，防止真实的头节点要被删除。后面的做法可以借鉴之前在remove duplicate array时遇到过的快慢指针的解法，但是由于之前remove array的时候是只把产生重复的去掉（保留一个），而现在是全部去掉，所以还是略微有一丢丢差别的。总结一下这个差别：如果只去掉重复的，那么慢指针应当一直指向开始重复的第一个元素；而如果所有都要去掉，那么慢指针应当指向开始重复的第一个元素之前的一个元素。具体这其中的微妙之处可能后面还需要自己再多体会一下。在快指针不为NULL的情况下，如果快指针指向的数字和下一个数字不同，则不用动，然后快慢指针分别往后移一位；如果快指针指向的数字和下一个数字相同，则一直把快指针移到最后一个重复数字时停止，然后把慢指针的next接到快指针的next上，并让快指针指向慢指针后面。最后返回的时候，注意需要去掉我们新创建的头节点。

/**
 * 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) {
        ListNode* new_head = new ListNode(-1);
        new_head->next = head;
        
        ListNode* slow = new_head;
        ListNode* fast = head;
        
        while (fast) {
            while (fast->next && fast->next->val == fast->val) {
                fast = fast->next;
            }
            if (slow->next != fast) {
                slow->next = fast->next;
                fast = slow->next;
            }
            else {
                slow = fast;
                fast = fast->next;
            }
        }
        
        return new_head->next; //注意返回的时候需要去掉我们新创建的头节点
    }
};