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 <= val <= 50
题解
链表入门题目。 ⚠️ 注意
1️⃣ 虚拟头节点 dummyHead
的运用(便于统一操作)
2️⃣ 每次删除节点后,下一个节点可能还是要删除的,所以应该检测到下一个不是要删除的节点后,再将指针移动、指向下一个节点。
代码(C++)
ListNode *removeElements(ListNode *head, int val)
{
ListNode *dummyHead = new ListNode(0, head);
ListNode *cur = dummyHead;
while (cur->next) {
if (cur->next->val == val)
cur->next = cur->next->next;
else
cur = cur->next;
}
return dummyHead->next;
}
无链表基础的同学建议移步 代码随想录 (programmercarl.com) 看这题的详解。
707. 设计链表
题目描述
你可以选择使用单链表或者双链表,设计并实现自己的链表。
单链表中的节点应该具备两个属性:val
和 next
。val
是当前节点的值,next
是指向下一个节点的指针/引用。
如果是双向链表,则还需要属性 prev
以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。
实现 MyLinkedList
类:
MyLinkedList()
初始化MyLinkedList
对象。int get(int index)
获取链表中下标为index
的节点的值。如果下标无效,则返回-1
。void addAtHead(int val)
将一个值为val
的节点插入到链表中第一个元素之前。在插入完成后,新节点会成为链表的第一个节点。void addAtTail(int val)
将一个值为val
的节点追加到链表中作为链表的最后一个元素。void addAtIndex(int index, int val)
将一个值为val
的节点插入到链表中下标为index
的节点之前。如果index
等于链表的长度,那么该节点会被追加到链表的末尾。如果index
比长度更大,该节点将 不会插入 到链表中。void deleteAtIndex(int index)
如果下标有效,则删除链表中下标为index
的节点。
示例:
输入
["MyLinkedList", "addAtHead", "addAtTail", "addAtIndex", "get", "deleteAtIndex", "get"]
[[], [1], [3], [1, 2], [1], [1], [1]]
输出
[null, null, null, null, 2, null, 3]
解释
MyLinkedList myLinkedList = new MyLinkedList();
myLinkedList.addAtHead(1);
myLinkedList.addAtTail(3);
myLinkedList.addAtIndex(1, 2); // 链表变为 1->2->3
myLinkedList.get(1); // 返回 2
myLinkedList.deleteAtIndex(1); // 现在,链表变为 1->3
myLinkedList.get(1); // 返回 3
提示:
0 <= index, val <= 1000
- 请不要使用内置的 LinkedList 库。
- 调用
get
、addAtHead
、addAtTail
、addAtIndex
和deleteAtIndex
的次数不超过2000
。
题解
本身没什么难度,但是可以较完整地过一遍链表的各项操作设计,非常有助于加深理解。
代码上要注意的可能就是下标的合法判断和防止指针越界。个人经验是利用虚头节点,带入第一个真实节点(下标为0的节点)考虑,有助于快速判断。例如,取指定下标节点的值时:
ListNode *cur = dummyHead;
for (int i = 0; i <= index; i++)
cur = cur->next;
这里for循环终止判断是 <=
,比如考虑取下标为0的节点,即 dummyHead->next
,如果用 <
终止for循环, cur
都无法移动、最终还是指向虚头节点。所以为了让 cur
进for循环走一次也得用 <=
( 🐶 )。
而在删除指定下标的节点时:
ListNode *cur = dummyHead;
for (int i = 0; i < index; i++)
cur = cur->next;
cur->next = cur->next->next;
由于我们需要定位到待删除节点的前驱节点,还是用删除下标为0的节点考虑,那么 cur
应该不需要往前走、直接保持指向 dummyHead
就好了,所以不用它进for循环,条件判断用 <
。
代码(C++)
class MyLinkedList
{
private:
// 链表节点
struct ListNode
{
int val;
ListNode *next;
ListNode() : val(0), next(nullptr) {}
ListNode(int x) : val(x), next(nullptr) {}
ListNode(int x, ListNode *next) : val(x), next(next) {}
};
int len; // 当前链表长度
ListNode *dummyHead; // 链表虚头节点
public:
MyLinkedList()
{
dummyHead = new ListNode();
len = 0;
}
int get(int index)
{
if (index >= len || index < 0)
return -1;
ListNode *cur = dummyHead;
for (int i = 0; i <= index; i++)
cur = cur->next;
return cur->val;
}
void addAtHead(int val)
{
ListNode *newHead = new ListNode(val, dummyHead->next);
dummyHead->next = newHead;
len++;
}
void addAtTail(int val)
{
addAtIndex(len, val);
}
void addAtIndex(int index, int val)
{
if (index < 0 || index > len)
return;
ListNode *cur = dummyHead;
for (int i = 0; i < index; i++)
cur = cur->next;
ListNode *newNode = new ListNode(val, cur->next);
cur->next = newNode;
len++;
}
void deleteAtIndex(int index)
{
if (index < 0 || index >= len)
return;
ListNode *cur = dummyHead;
for (int i = 0; i < index; i++)
cur = cur->next;
cur->next = cur->next->next;
len--;
}
};
206. 反转链表
题目描述
给你单链表的头节点 head
,请你反转链表,并返回反转后的链表。
示例 1:
输入:head = [1,2,3,4,5]
输出:[5,4,3,2,1]
示例 2:
输入:head = [1,2]
输出:[2,1]
示例 3:
输入:head = []
输出:[]
提示:
- 链表中节点的数目范围是
[0, 5000]
-5000 <= Node.val <= 5000
进阶: 链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题?
题解
我的思路是用一个新链表存储反转后的结果,然后遍历原链表,将遍历到的节点依次插入新链表的头部,结束后新链表自然就是反转后的样子了。这样写下来的代码我感觉也比较简洁优雅。
代码(C++)
ListNode *reverseList(ListNode *head)
{
// 思路:开一个新链表,采用头插法依次插入原来链表的节点
ListNode *dummyHead = new ListNode();
while (head) {
dummyHead->next = new ListNode(head->val, dummyHead->next);
head = head->next;
}
return dummyHead->next;
}
看了下 卡哥的解法 ,也mark在此以供参考:
双指针解法
ListNode* reverseList(ListNode* head) {
ListNode* temp; // 保存cur的下一个节点
ListNode* cur = head;
ListNode* pre = NULL;
while(cur) {
temp = cur->next; // 保存一下 cur的下一个节点,因为接下来要改变cur->next
cur->next = pre; // 翻转操作
// 更新pre 和 cur指针
pre = cur;
cur = temp;
}
return pre;
}
递归法
ListNode* reverse(ListNode* pre,ListNode* cur){
if(cur == NULL) return pre;
ListNode* temp = cur->next;
cur->next = pre;
// 可以和双指针法的代码进行对比,如下递归的写法,其实就是做了这两步
// pre = cur;
// cur = temp;
return reverse(cur,temp);
}
ListNode* reverseList(ListNode* head) {
// 和双指针法初始化是一样的逻辑
// ListNode* cur = head;
// ListNode* pre = NULL;
return reverse(NULL, head);
}
递归法没什么好说的了,我的写法时空复杂度都是 O ( n ) O(n) O(n) ,但是双指针可以原地修改,空间复杂度为 O ( 1 ) O(1) O(1) 。
又想了一下,我的写法其实每次遍历过后把原来链表节点的空间释放掉,一抵消,空间复杂度是不是也算 O ( 1 ) O(1) O(1) 哈哈哈哈哈 😆
anyway其实根据实际情况决定要不要保留原链表就好。