代码随想录: 404 | 代码随想录
24. 两两交换链表中的节点
交换过程中的步骤有点复杂, 要结合示意图想清楚
代码随想录链接: https://programmercarl.com/0024.两两交换链表中的节点.html#思路
/**
* 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* dummyHead = new ListNode(0, head);
auto cur = dummyHead;
while (cur->next != nullptr && cur->next->next != nullptr) {
auto temp0 = cur->next;
auto temp1 = cur->next->next->next;
cur->next = cur->next->next;
cur->next->next = temp0;
cur->next->next->next = temp1;
cur = cur->next->next;
}
head = dummyHead->next;
delete dummyHead;
return head;
}
};
过程中产生了疑问:
dummyHead->next在循环中不会被改变吗, 为什么最后可以返回dummyHead->next, 于是我询问了Claude, 问题解决, 感觉应该能想到原因的, 神智有点不清了. 以下为Claude sonnet3.5的答案:
你提出了一个很好的问题。让我详细解释一下为什么 dummyHead->next
在循环中会改变,但最终仍然可以正确地返回反转后的链表头:
dummyHead->next
确实会在循环的第一次迭代中被改变。但这个改变恰恰是我们想要的,因为它会指向新的链表头。- 让我们一步步看循环的第一次迭代:
- 初始状态:dummyHead -> 1 -> 2 -> 3 -> 4
- 交换后: dummyHead -> 2 -> 1 -> 3 -> 4
- 在这个过程中,
dummyHead->next
从指向节点1变成了指向节点2。这正是我们想要的结果,因为在交换对之后,节点2应该成为新的链表头。 - 在随后的迭代中,
cur
会向前移动,但dummyHead->next
不会再改变,因为我们始终在cur
之后的节点上操作。 - 循环结束后,链表可能看起来像这样(假设有偶数个节点): dummyHead -> 2 -> 1 -> 4 -> 3 -> null
- 因此,当我们最后返回
dummyHead->next
时,它正好指向反转后的链表的新头部(在这个例子中是节点2)。
总结:
dummyHead->next
在第一次迭代中确实会改变,这个改变使它指向新的链表头。- 在后续迭代中,
dummyHead->next
保持不变,而我们通过移动cur
来处理链表的其余部分。 - 最终,
dummyHead->next
指向的正是我们想要的新链表头,所以可以直接返回它。
这种使用虚拟头节点(dummy head)的技巧非常有用,尤其是在需要修改链表头的情况下,它简化了边界情况的处理。
19. 删除链表的倒数第 N 个结点
一次遍历的重点是想到让快指针先走n步
/**
* 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* removeNthFromEnd(ListNode* head, int n) {
ListNode *dummyHead = new ListNode(0, head);
auto slow = dummyHead, fast = dummyHead;
while (n-- && fast != nullptr) {
fast = fast->next;
}
fast = fast->next;
while (fast != nullptr) {
fast = fast->next;
slow = slow->next;
}
auto temp = slow->next;
slow->next = slow->next->next;
delete temp;
head = dummyHead->next;
delete dummyHead;
return head;
}
};
面试题 02.07. 链表相交
代码随想录比较容易理解的方法(但其实也不容易):
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* getIntersectionNode(ListNode* headA, ListNode* headB) {
auto cur1 = headA;
auto cur2 = headB;
int lengthA = 0, lengthB = 0;
while (cur1 != NULL) {
lengthA++;
cur1 = cur1->next;
}
while (cur2 != NULL) {
lengthB++;
cur2 = cur2->next;
}
cur1 = headA;
cur2 = headB;
if (lengthA < lengthB) {
swap(cur1, cur2);
swap(lengthA, lengthB);
}
int gap = lengthA - lengthB;
while (gap--) {
cur1 = cur1->next;
}
while (cur1 != NULL && cur2 != NULL) {
if (cur1 == cur2) {
return cur1;
} else {
cur1 = cur1->next;
cur2 = cur2->next;
}
}
return NULL;
}
};
好聪明的解法, 我一辈子也想不到了:
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
auto h1 = headA, h2 = headB;
while (h1 != h2) {
if (h1 != NULL) {
h1 = h1->next;
} else {
h1 = headB;
}
if (h2 != NULL) {
h2 = h2->next;
} else {
h2 = headA;
}
}
return h1;
}
};
解题思路(k神的题解): . - 力扣(LeetCode)
142. 环形链表 II
数学方面比较难理解, 看代码随想录吧: https://programmercarl.com/0142.环形链表II.html#思路
快指针每次移动两个节点, 慢指针每次移动一个节点, 如果有环, 那么他们一定会在环里相遇
/**
* 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) {
auto fast = head;
auto slow = head;
while (fast != NULL && fast->next != NULL) {
fast = fast->next->next;
slow = slow->next;
if (fast == slow) {
auto index1 = fast;
auto index2 = head;
while (index1 != index2) {
index1 = index1->next;
index2 = index2->next;
}
return index1;
}
}
return NULL;
}
};
总结
如果涉及到增删改就使用虚拟头节点, 是为了
- 不用特判头节点的情况
- 头节点可能会被改变, 方便最后返回
dummyHead→next