链表算法面试题---删除链表中的重复元素II

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

举例：
原链表: 1->2->3->3->4->4->5
删除后: 1->2->5

解法1：

结合删除重复节点和删除指定节点的方式，可以先删除重复节点，并记录下来重复节点的值，然后再删除指定节点的值即可。

public class Code_06 {
    
    

    public static void main(String[] args) {
    
    
        Code_06 c = new Code_06();
        ListNode n = new ListNode();
        ListNode head = n;
        for (int i = 1; i <= 5; i++) {
    
    
            n.next = new ListNode(i);
            n = n.next;
            if (i % 2 == 0) {
    
    
                n.next = new ListNode(i);
                n = n.next;
            }
        }
        System.out.println(head);
        System.out.println(c.deleteDuplicates(head));
    }

    public ListNode deleteDuplicates(ListNode head) {
    
    
        ListNode cur = head;
        Set<Integer> dupSet = new HashSet<>();
        while (cur != null && cur.next != null) {
    
    
            if (cur.val != cur.next.val) {
    
    
                cur = cur.next;
            } else {
    
    
                dupSet.add(cur.val);
                cur.next = cur.next.next;
            }
        }
        for (Integer val : dupSet) {
    
    
            head = deleteNode(head, val);
        }
        return head;
    }

    private ListNode deleteNode(ListNode head, int val) {
    
    
        while (head != null) {
    
    
            if (head.val != val) {
    
    
                break;
            }
            head = head.next;
        }
        ListNode pre = null;
        ListNode cur = head;
        while (cur != null) {
    
    
            if (cur.val == val) {
    
    
                pre.next = cur.next;
            } else {
    
    
                pre = cur;
            }
            cur = cur.next;
        }
        return head;
    }

}

第一种方式显然不够优雅，换一种思路，通过哑节点+双指针实现

public class Code_06_01 {
    
    
    public static void main(String[] args) {
    
    
        Code_06_01 c = new Code_06_01();
        ListNode n = new ListNode();
        ListNode head = n;
        for (int i = 1; i <= 5; i++) {
    
    
            n.next = new ListNode(i);
            n = n.next;
            if (i % 2 == 0) {
    
    
                n.next = new ListNode(i);
                n = n.next;
            }
        }
        System.out.println(head);
        System.out.println(c.deleteDuplicates(head));
    }

    /**
     * 哑节点+双指针
     * <p>
     * 构建一个哑节点，让其next指向头位置。
     * 再利用双指针，n1,n2,初始都指向head位置，如果n1.next.val==n2.next.val，则让n2向前移动一位，否则n1，n2一起向前移动一位
     *
     * @param head
     * @return
     */
    public ListNode deleteDuplicates(ListNode head) {
    
    
        ListNode dummy = new ListNode();
        dummy.next = head;
        ListNode n1 = dummy;
        ListNode n2 = head;
        while (n2 != null && n2.next != null) {
    
    
            if (n1.next.val != n2.next.val) {
    
    
                n1 = n1.next;
            } else {
    
    
                //n2一直移动，直到不等于n1为止
                while (n2 != null && n2.next != null && n1.next.val == n2.next.val) {
    
    
                    n2 = n2.next;
                }
                n1.next = n2.next;
            }
            n2 = n2.next;
        }
        return dummy.next;
    }
}