代码随想录算法训练营第四天| 24. 两两交换链表中的节点 19.删除链表的倒数第N个节点 142.环形链表II

最新推荐文章于 2026-08-22 23:33:41 发布

原创最新推荐文章于 2026-08-22 23:33:41 发布 · 939 阅读

20 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

24. 两两交换链表中的节点

用虚拟头结点，这样会方便很多。

本题链表操作就比较复杂了，建议大家先看视频，视频里我讲解了注意事项，为什么需要temp保存临时节点。

题目链接/文章讲解/视频讲解：代码随想录

第一点：注意循环条件由于要操作两个节点，所以循环条件当前遍历节点后两个节点是否为空。

第二点：在遍历中要两个两个跳过遍历，符合题目需求

第三点：应该用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) {

if(nullptr == head)

{

return nullptr;

}

ListNode *dummy = new ListNode(0);

ListNode *cur = dummy;

dummy->next = head;

while(cur->next != nullptr && cur->next->next != nullptr)

{

ListNode *tmp = cur->next;

ListNode *tmp2 = cur->next->next->next;

cur->next = cur->next->next;

cur->next->next = tmp;

cur->next->next->next = tmp2;

cur = cur->next->next;

}

ListNode* res = dummy->next;

delete dummy;

return res;

}

};

19.删除链表的倒数第N个节点

双指针的操作，要注意，删除第N个节点，那么我们当前遍历的指针一定要指向第N个节点的前一个节点，建议先看视频。

题目链接/文章讲解/视频讲解：代码随想录

此题用双指针法，又可以说是快慢指针法来实现一次遍历完成删除，即根据N的大小来决定快慢指针之前的距离，同时往后遍历，当快指针指向nullptr时，慢指针需要指向被删除节点前一个节点，这样直接操作慢指针即可

/**

* 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 *dummy = new ListNode(0);

dummy->next = head;

ListNode *slow = dummy;

ListNode *fast = dummy;

ListNode *tmp = nullptr;

while(n && fast != nullptr)

{

fast = fast->next;

n--;

}

fast = fast->next;

while(fast != nullptr && slow != nullptr)

{

slow = slow->next;

fast = fast->next;

}

slow->next = slow->next->next;

ListNode *res = dummy->next;

delete dummy;

return res;

}

};

面试题 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) {

ListNode *curA = headA;

ListNode *curB = headB;

int lengthA = 0;

int lengthB = 0;

while(curA != nullptr)

{

lengthA++;

curA = curA->next;

}

while(curB != nullptr)

{

lengthB++;

curB = curB->next;

}

curA = headA;

curB = headB;

if(lengthB > lengthA)

{

swap(lengthA, lengthB);

swap(curA, curB);

}

int gap = lengthA - lengthB;

while(gap-- && curA != nullptr)

{

curA = curA->next;

}

while(curA != nullptr)

{

if(curA == curB)

{

return curA;

}

curA = curA->next;

curB = curB->next;

}

return nullptr;

}

};

142.环形链表II

算是链表比较有难度的题目，需要多花点时间理解确定环和找环入口，建议先看视频。

题目链接/文章讲解/视频讲解：代码随想录

环形链表问题：

1.还是遵循双指针即快慢指针策略，可以预见的是如果快指针每次后移两位，慢指针每次后移一位，如果链表中有环，两个指针必定会在环中相遇。

2.相遇点并不是环入口，想找到环入口则需要两个index指针从相遇点，和从起点同时遍历，当相等时则找到环入口。

/**

* 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) {

ListNode *slow = head;

ListNode *fast = head;

while(fast != nullptr && fast->next != nullptr)

{

slow = slow->next;

fast = fast->next->next;

if(slow == fast)

{

ListNode *index1 = head;

ListNode *index2 = slow;

while(index1 != nullptr && index2 != nullptr)

{

if(index1 == index2)

return index1;

index1 = index1->next;

index2 = index2->next;

}

return nullptr;

}

};

总结

对于链表的题目，大家最大的困惑可能就是什么使用用虚拟头结点，什么时候不用虚拟头结点？

一般涉及到增删改操作，用虚拟头结点都会方便很多，如果只能查的话，用不用虚拟头结点都差不多。

当然大家也可以为了方便记忆，统一都用虚拟头结点。

代码随想录

标签

#算法 #链表 #数据结构