一、知识点
一般涉及到 增删改操作,用虚拟头结点都会方便很多, 如果只能查的话,用不用虚拟头结点都差不多。
当然大家也可以为了方便记忆,统一都用虚拟头结点。
二、题目
24. 两两交换链表中的节点
做题链接:
https://leetcode.cn/problems/swap-nodes-in-pairs/description/
建议大家先看视频,视频里我讲解了注意事项,为什么需要temp保存临时节点。
视频链接:
帮你把链表细节学清楚! | LeetCode:24. 两两交换链表中的节点_哔哩哔哩_bilibili
做题思路
交换相邻两个元素需要按照三步走,更新cur,循环操作,直到没有要交换的数(即cur->next->next==NULL)
vir->1->2->3->4->NULL
cur->tmp->2->tmp1->4->NULL
vir->2->1->3->4->NULL
vir->2->cur->tmp->4->tmp1
vir->2->1->4->3->NULL
vir->2->1->4->cur->tmp
代码细节
/**
* Definition for singly-linked list.
* 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) {}
* };
*/
class Solution {
public:
ListNode* swapPairs(ListNode* head) {
// 创建一个虚拟头结点
ListNode* vir_head = new ListNode(0);
// 将虚拟头结点指向head
vir_head->next = head;
ListNode* cur = vir_head;
// cur->next->next表示要交换节点的前一位需要有值。
// 例如3和4交换,3的前一位需要有值
while (cur->next != NULL && cur->next->next != NULL)
{
ListNode* tmp = cur->next;
ListNode* tmp1 = cur->next->next->next;
// 交换操作,三步
// 步骤1:改变cur的指向
cur->next = tmp->next;
// 步骤2
cur->next->next = tmp;
// 步骤3:改变tmp的指向
tmp->next = tmp1;
// 更新cur,作为下次交换的前一位数,准备下次交换
cur = tmp;
}
return vir_head->next;
}
};
19.删除链表的倒数第N个节点
做题链接:
https://leetcode.cn/problems/remove-nth-node-from-end-of-list/description/
双指针的操作,要注意,删除第N个节点,那么我们当前遍历的指针一定要指向 第N个节点的前一个节点,建议先看视频
视频链接:
链表遍历学清楚! | LeetCode:19.删除链表倒数第N个节点_哔哩哔哩_bilibili
做题思路
法1:找节点->删除节点(自己做出来了)
1、找要删除的节点:遍历算链表长度len,倒数第n个节点就是正数第len-n个节点(正数是从0开始)
2、删除节点
法2:快慢指针(待掌握)
-
定义fast指针和slow指针,初始值为虚拟头结点,如图:
-
fast首先走n + 1步 ,为什么是n+1呢,因为只有这样同时移动的时候slow才能指向删除节点的上一个节点(方便做删除操作),如图:
-
fast和slow同时移动,直到fast指向末尾,如题:
-
删除slow指向的下一个节点,如图:
代码细节
// 法1
class Solution {
public:
ListNode* removeNthFromEnd(ListNode* head, int n) {
int len = 0;
// ListNode* vir_head = new ListNode(0, head);
ListNode* vir_head = new ListNode(0);
vir_head->next = head;
ListNode* cur = vir_head;
// 1、遍历计算链表长度
while (cur->next != NULL)
{
len++;
cur = cur->next;
}
// 2、找下标为pos的节点
// 例如,下标为0
int pos = len - n;
// 遍历从虚拟头结点开始
cur = vir_head;
while (pos)
{
cur = cur->next;
pos--;
}
// 3、删除该节点
ListNode* tmp = cur->next;
cur->next = cur->next->next;
delete tmp;
tmp = NULL;
len--;
//4、返回虚拟头结点的指向
return vir_head->next;
}
};
// 法2
class Solution {
public:
ListNode* removeNthFromEnd(ListNode* head, int n) {
ListNode* dummyHead = new ListNode(0);
dummyHead->next = head;
ListNode* slow = dummyHead;
ListNode* fast = dummyHead;
while(n-- && fast != NULL) {
fast = fast->next;
}
fast = fast->next; // fast再提前走一步,因为需要让slow指向删除节点的上一个节点
while (fast != NULL) {
fast = fast->next;
slow = slow->next;
}
slow->next = slow->next->next;
// ListNode *tmp = slow->next; C++释放内存的逻辑
// slow->next = tmp->next;
// delete tmp;
return dummyHead->next;
}
};
160. 链表相交
做题链接:
https://leetcode.cn/problems/intersection-of-two-linked-lists-lcci/description/
注意 数值相同,不代表指针相同
题意有点看不太懂
做题思路
代码细节(待)
class Solution {
public:
ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
ListNode* curA = headA;
ListNode* curB = headB;
int lenA = 0, lenB = 0;
while (curA != NULL) { // 求链表A的长度
lenA++;
curA = curA->next;
}
while (curB != NULL) { // 求链表B的长度
lenB++;
curB = curB->next;
}
curA = headA;
curB = headB;
// 让curA为最长链表的头,lenA为其长度
if (lenB > lenA) {
swap (lenA, lenB);
swap (curA, curB);
}
// 求长度差
int gap = lenA - lenB;
// 让curA和curB在同一起点上(末尾位置对齐)
while (gap--) {
curA = curA->next;
}
// 遍历curA 和 curB,遇到相同则直接返回
while (curA != NULL) {
if (curA == curB) {
return curA;
}
curA = curA->next;
curB = curB->next;
}
return NULL;
}
};
142.环形链表II(待)
做题链接:
https://leetcode.cn/problems/linked-list-cycle-ii/description/
算是链表比较有难度的题目,需要多花点时间理解 确定环和找环入口,建议先看视频
视频链接:
把环形链表讲清楚! 如何判断环形链表?如何找到环形链表的入口? LeetCode:142.环形链表II_哔哩哔哩_bilibili
做题思路
代码细节
法1:哈希
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode *detectCycle(ListNode *head) {
// 法1:哈希,把链表节点的值存进数组里,次数>1说明是入环的起点
// 定义一个 集合 visited 来存储已经访问过的节点
unordered_set<ListNode *> visited;
// 遍历链表
// 只要 head(当前节点)不是 nullptr(即链表未结束),就继续循环。
while (head != nullptr) {
// 检查head是否已经在 visited 集合中。
// 如果是,说明之前已经访问过这个节点,因此链表中存在环,直接返回 head
if (visited.count(head)) {
return head;
}
// 如果 head 不在 visited 集合中,我们将其添加到集合中
visited.insert(head);
// 移动到下一个节点
head = head->next;
}
// 如果链表中没有环,那么最终 head 会变为nullptr
return nullptr;
}
};
法2:快慢指针在环里相遇(待)
class Solution {
public:
ListNode *detectCycle(ListNode *head) {
ListNode* fast = head;
ListNode* slow = head;
while(fast != NULL && fast->next != NULL) {
slow = slow->next;
fast = fast->next->next;
// 快慢指针相遇,此时从head 和 相遇点,同时查找直至相遇
if (slow == fast) {
ListNode* index1 = fast;
ListNode* index2 = head;
while (index1 != index2) {
index1 = index1->next;
index2 = index2->next;
}
return index2; // 返回环的入口
}
}
return NULL;
}
};