LeetCode83: 删除排序链表中的重复元素

给定一个已排序的链表的头 head ， 删除所有重复的元素，使每个元素只出现一次 。返回 已排序的链表 。

示例 1：
输入：head = [1,1,2]
输出：[1,2]

示例 2：
输入：head = [1,1,2,3,3]
输出：[1,2,3]
提示：

链表中节点数目在范围 [0, 300] 内
-100 <= Node.val <= 100
题目数据保证链表已经按升序 排列
Related Topics
链表

1. 遍历

• 只需要对有序链表遍历，遇到current.val等于current.next.val，就将current.next指向current.next.next即可，如果不相等，current后移一位；当遍历完链表之后，返回链表的头节点即可。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if (head == null) {
            return null;
        }
        ListNode current = head;
        while (current.next != null) {
            if (current.val == current.next.val) {
                current.next = current.next.next;
            }else {
                current = current.next;
            }
        }
        return head;
    }
}

• 复杂度分析
  时间复杂度：O(n)，其中 n 是链表的长度。
  空间复杂度：O(1)。

2. 递归

• 递归，其实是将链表压栈后倒序处理，每次检查相邻的2个节点，如果发现最后面连续的2个节点的值相等，则保留第二个节点，删除前面的节点，这样才能保证后面的节点都挂在到链表上；如果不相等，则返回第一个节点。

    // 递归，其实是将链表压栈后倒序处理
    public ListNode deleteDuplicates(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        head.next = deleteDuplicates(head.next);
        if (head.val != head.next.val) {
            return head;
        } else {
            return head.next;
        }
    }

• 复杂度分析
  时间复杂度：O(n)，其中 n 是链表的长度。
  空间复杂度：O(n)，入栈 n 次。