LeetCode 08: T203. 移除链表元素（简单）； T876. 链表的中间结点（简单）； T83. 删除排序链表中的重复元素（简单）

本文介绍了解决三个经典链表问题的高效方法：移除链表元素、寻找链表中间节点及删除排序链表中的重复元素。通过使用哨兵节点、双指针等技巧，文章详细阐述了每种方法的时间与空间复杂度。

文章目录

T1: 203. 移除链表元素（简单）
T2: 876. 链表的中间结点（简单）
T3: 83. 删除排序链表中的重复元素（简单）

T1: 203. 移除链表元素（简单）

网址

https://leetcode-cn.com/problems/remove-linked-list-elements/

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回新的头节点。

示例 1：

输入：head = [1,2,6,3,4,5,6], val = 6
输出：[1,2,3,4,5]

示例 2：

输入：head = [], val = 1
输出：[]

示例 3：

输入：head = [7,7,7,7], val = 7
输出：[]

提示：

列表中的节点在范围 [0, 104] 内
1 <= Node.val <= 50
0 <= k <= 50

思路

用哨兵的方法来伪头

解法 1:

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode sentinel = new ListNode(0);
        sentinel.next = head;
        ListNode prev = sentinel, curr = head;
        while(curr !=null){
            if(curr.val == val) prev.next = curr.next;
            else prev = curr;
            curr = curr.next;
        }
        return sentinel.next;
    }
}

执行用时：1 ms, 在所有 Java 提交中击败了**99.79%**的用户

内存消耗：39.7 MB, 在所有 Java 提交中击败了**10.74%**的用户

时间复杂度：O(N)，只遍历了一次。

空间复杂度：O(1)。

易错点:

T2: 876. 链表的中间结点（简单）

网址

https://leetcode-cn.com/problems/middle-of-the-linked-list/

给定一个头结点为 head 的非空单链表，返回链表的中间结点。

如果有两个中间结点，则返回第二个中间结点。

示例 1：

输入：[1,2,3,4,5]
输出：此列表中的结点 3 (序列化形式：[3,4,5])
返回的结点值为 3 。 (测评系统对该结点序列化表述是 [3,4,5])。
注意，我们返回了一个 ListNode 类型的对象 ans，这样：
ans.val = 3, ans.next.val = 4, ans.next.next.val = 5, 以及 ans.next.next.next = NULL.

示例 2：

输入：[1,2,3,4,5,6]
输出：此列表中的结点 4 (序列化形式：[4,5,6])
由于该列表有两个中间结点，值分别为 3 和 4，我们返回第二个结点。

提示：

给定链表的结点数介于 1 和 100 之间。

思路

可以用数组存储数据

解法 1: 数组

class Solution {
    public ListNode middleNode(ListNode head) {
        ListNode[] list = new ListNode[100];
        int count = 0;
        while(head!=null){
            list[count++]=head;
            head = head.next;
        }
        return list[count/2];
    }
}

执行用时：0 ms, 在所有 Java 提交中击败了**100.00%**的用户

内存消耗：35.6 MB, 在所有 Java 提交中击败了**78.16%**的用户

时间复杂度：O(N)，其中 N 是给定链表中的结点数目。

空间复杂度：O(N)，即数组 A 用去的空间。

解法 2[X]: 单指针法

class Solution {
    public ListNode middleNode(ListNode head) {
        int n = 0;
        ListNode cur = head;
        while (cur != null) {
            ++n;
            cur = cur.next;
        }
        int k = 0;
        cur = head;
        while (k < n / 2) {
            ++k;
            cur = cur.next;
        }
        return cur;
    }
}

时间复杂度：O(N)，其中 N 是给定链表的结点数目。

空间复杂度：O(1)，只需要常数空间存放变量和指针。

解法 3: 双指针

class Solution {
    public ListNode middleNode(ListNode head) {
        ListNode slow = head, fast = head;
        while(fast!=null&&fast.next!=null){
            slow = slow.next;
            fast = fast.next.next;
        }
        return slow;
    }
}

执行用时：0 ms, 在所有 Java 提交中击败了**100.00%**的用户

内存消耗：36 MB, 在所有 Java 提交中击败了**5.21%**的用户

时间复杂度：O(N)，其中 N 是给定链表的结点数目。

空间复杂度：O(1)，只需要常数空间存放 slow 和 fast 两个指针。

易错点:

双指针为什么是 fast和 fast.next

T3: 83. 删除排序链表中的重复元素（简单）

网址

https://leetcode-cn.com/problems/remove-duplicates-from-sorted-list/

存在一个按升序排列的链表，给你这个链表的头节点 head ，请你删除所有重复的元素，使每个元素只出现一次。

返回同样按升序排列的结果链表。

示例 1：

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

示例 2：

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

提示：

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

思路

解法 1:

class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if(head==null) return head;
        ListNode cur = head;
        while(cur.next!=null){
            if(cur.val==cur.next.val) cur.next = cur.next.next;
            else cur = cur.next;
        }
        return head;
    }
}