携手创作，共同成长！这是我参与「掘金日新计划 · 8 月更文挑战」的第30天，点击查看活动详情
T1: 203. 移除链表元素 （简单）
网址
给你一个链表的头节点 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. 链表的中间结点（简单）
网址
给定一个头结点为 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. 删除排序链表中的重复元素（简单）
网址
存在一个按升序排列的链表，给你这个链表的头节点 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;
}
}
执行用时：0 ms, 在所有 Java 提交中击败了**100.00%**的用户
内存消耗：38 MB, 在所有 Java 提交中击败了**26.69%**的用户
时间复杂度：O(n)，其中 n 是链表的长度。
空间复杂度：O(1)。
易错点:
为什么返回的是head
