82. 删除排序链表中的重复元素 II

82. 删除排序链表中的重复元素 II

给定一个排序链表，删除所有含有重复数字的节点，只保留原始链表中 没有重复出现 的数字。

示例 1:
输入: 1->2->3->3->4->4->5
输出: 1->2->5

示例 2:
输入: 1->1->1->2->3
输出: 2->3

方法1：递归

算法思路：

1. 找终止条件：当 head 指向链表只剩一个元素的时候，自然是不可重复的，因此 return ；
2. 以 1->1->1->2->3 为例：
   1. 则需要移动 next 直到出现与当前 head.value 不相等的情况（含null)
   2. 并且此时的 head 已经不能要来，因为 head 已经是重复的结点
3. 以 1->2->3 为例：如果没有出现上面的情况，则递归返回结点就作为 head 的子节点

参考代码1：

class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        ListNode next = head.next;
        //如果是这种情况
        //      1 --> 1 --> 1 --> 2 --> 3
        //     head  next
        //1.则需要移动next直到出现与当前head.value不相等的情况（含null）
        //2.并且此时的head已经不能要了，因为已经head是重复的节点
        //--------------else-------------
        //      1 --> 2 --> 3
        //     head  next
        //3.如果没有出现1的情况，则递归返回的节点就作为head的子节点
        if (head.val == next.val) {
            // 1
            while (next != null && head.val == next.val){
                next = next.next;
            }
            // 2
            head = deleteDuplicates(next);
        } else {
            // 3
            head.next = deleteDuplicates(next);
        }
        return head;
    }
}

复杂度分析：

• 时间复杂度：O(n)，n 是链表中结点数，因为链表中每个结点都检查一次以确定是否重复。
• 空间复杂度：O(n)，递归过程使用的栈空间。

方法2：双指针

算法思路：

使用双指针的方式，定义 a , b 两个指针。
考虑到一些边界，比如 1->1->1->2->3 这种情况，需要把开头的几个 1 给去掉，我们增加一个 哑结点 ，方便边界处理。

初始的两个指针如下：

• 将 a 指针指向哑结点
• 将 b 指针指向 head (哑结点的下一个结点)

如果 a 指向的值 不等于 b 指向的值，则两个指针都前进一位，否则，就单独移动 b，b 不断往前走，直到 a 指向的值 不等于 b 指向的值。

注意：这里不是直接比较 a.val == b.val , 这么比较不对，因为初始的时候，a 指向的是哑结点，所以比较逻辑应该是： a.next.val == b.next.val 。

当两个指针指向的值相等时，b 不断往前移动，这里通过一个 while 循环判断，因为要过滤掉 1->2->2->2->3 重复的 2。
那么整个逻辑就是两个 while , 但是时间复杂度 不是 $$O(n^2)$$ ，而是$$O(n)$$，空间上也只是常数级别。

参考代码2:

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        ListNode a = dummy;
        ListNode b = head;
        while (b != null && b.next != null) {
            // a 指向的值 与 b 指向的值不同，则两个指针都往前走一步
            if (a.next.val != b.next.val) {
                a = a.next;
                b = b.next;
            } else {
                // 如果a、b指向的结点值相等，就不断的移动b，直到a、b指向的值不等
                while (b != null && b.next != null && a.next.val == b.next.val) {
                    b = b.next;
                }
                a.next = b.next;
                b = b.next;
            }
        }
        return dummy.next;
    }
}

复杂度分析：

• 时间复杂度：O(n)。
• 空间复杂度：O(1)。