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

今日学习的文章和视频链接

24文章链接: link
24视频讲解链接: link
19文章链接: link
19视频讲解链接: link
面试题 02.07文章链接: link
面试题 02.07暂无视频讲解
142文章链接: link
142视频讲解链接: link

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

看到题目第一想法

题目：
给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

有如下想法：
将相邻两节点的交换写进循环中，完成两两交换，循环中的关键是修改节点指针指向的顺序问题和临时节点的记录。

看完代码随想录后的想法

代码随想录通过画图来表示指针的操作步骤，指针的操作顺序一目了然。

初始时，cur指向虚拟头节点，然后进行如下三步：

操作之后，链表如下：

通过上述三步完成相邻两个元素的交换。

接下来只需循环这个操作就可以完成对整个链表中相邻节点的两两交换。

实现过程中遇到的困难

开始没有记录临时节点，因为2节点已经断开和3节点的连接，导致步骤二中1节点的next找不到3节点的位置。

所以一定要在对节点指针进行操作前记录临时节点。

ListNode* cur = dummyHead;

设置指针cur指向虚拟头节点

代码

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummyHead = new ListNode(0);//设置一个虚拟头节点
        dummyHead->next = head;
        ListNode* cur = dummyHead;
        while(cur->next != nullptr && cur->next->next != nullptr){
            ListNode* tmp = cur->next;
            ListNode* tmp1 = cur->next->next->next;
			//以下三步与图中操作相对应
            cur->next = cur->next->next;
            cur->next->next = tmp;
            cur->next->next->next = tmp1;

            cur = cur->next->next;
        }
        return dummyHead->next;
    }
};

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

看到题目第一想法

题目：
给你一个链表，删除链表的倒数第 n个结点，并且返回链表的头结点。

有如下想法：
删除链表中的指定的倒数节点可以通过快慢指针来完成，先让快指针移动n步，然后slow开始和fast同时移动，当fast到达链表末尾时，删掉slow所指指针即可。

看完代码随想录后的想法

代码随想录分为如下几步：

• 定义fast指针和slow指针，初始值为虚拟头节点，如图：
  
• fast首先走n+1步，为什么是n+1步呢，因为只有这样同时移动的时候slow才能指向删除节点的上一个节点，如图：

• fast和slow同时移动，直到fast指向末尾，如图：

• 删除slow指向的下一个节点，如图：

实现过程中遇到的困难

实现时一定要注意让fast移动n+1步后再同时移动fast和slow指针，这样才能使slow指向要删除节点的前一个节点。

再让slow的next指向要删除节点的next，这样就完成了对该节点的删除。

代码

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode* slow = dummyHead;
        ListNode* fast = dummyHead;
        n++;
        while(n-- && fast != NULL){
            fast = fast->next;
        }
        while (fast != NULL){
            fast = fast->next;
            slow = slow->next;
        }
        slow->next = slow->next->next;
        return dummyHead->next;
    }
};

面试题 02.07. 链表相交

看到题目第一想法

题目描述：
给你两个单链表的头节点 headA和 headB，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null。

有如下想法：
指针如果要相交，那么从相交节点开始的节点内元素都是相等的，求出两个链表的长度差，假设长度差为n，再让较长链表的指针先移动到n+1的位置，再同时移动两个链表的指针，直到两个指针相遇找到交点。

看完代码随想录后的想法

思路与我的想法一致

实现过程中遇到的困难

未遇到困难

代码

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

看到题目第一想法

题目描述：

给定一个链表的头节点 head，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

有如下想法：

• 判断是否有环：采用快慢指针法，定义fast和slow指针，从头节点开始，fast指针每次移动两个节点，slow指针每次移动一个节点，如果两指针在途中相遇，则该链表有环。
• 如何找到环的入口：有两个关键点——环形入口节点和指针相遇节点。

假设头节点到环形入口节点的节点数为x，环形入口节点到两指针相遇节点节点数为y，相遇节点到环形入口节点数为z。

当两指针相遇时，slow指针走过节点数为：x+y，fast指针走过节点数：x+y+n（y + z）
其中n为fast指针在环内第一次遇到slow指针时已经在环内走了n圈。
（y + z）为一圈内节点的个数。

又因为fast指针走两步，slow走一步（物理上可以理解为相当于fast的速度是slow的两倍），这样fast走过的路程就是slow的两倍。
由此得到公式：
(x + y) * 2 = x + y + n (y + z)

对公式进行消元和移项得到：
x = n (y + z) - y

为了使公式中不出现减法，从从n(y+z)中提出一个 （y+z）来，整理公式之后为如下公式：
x = (n - 1) (y + z) + z

该公式的含义是：从头结点出发一个指针，从相遇节点 也出发一个指针，这两个指针每次只走一个节点， 那么当这两个指针相遇的时候就是 环形入口的节点。

看完代码随想录后的想法

代码随想录中的动画更加直观的表示了指针相遇的情况和如何找到环形入口。

fast指针与slow指针相遇：

环形链表关键节点距离示意图：

寻找入口节点示意图：

实现过程中遇到的困难

因为这是第二次见过该题，所以有一定的印象。但第一次见到该题时有一个疑问：为什么第一次在环中相遇，slow的步数是 x+y 而不是 x + 若干圈的长度 + y？

原因如下：

首先slow进环时，fast早已进入环中。

如果slow进环入口，fast也在环入口，那么把这个环展开成直线，就如下图：

可以看出如果slow和fast同时在环入口开始走，那么他们一定会在环入口3相遇，此时slow走了一圈，fast走了两圈。

当slow进环时，我们假设fast在环的任意一个位置，如图：

那么fast指针走到环入口3的时候，已经走了k + n 个节点，slow相应的应该走了(k + n) / 2 个节点。

因为k < n，所以(k + n) / 2一定也小于n。

这说明在slow走的第一环内就会和fast相遇了。

而且fast是不会跳过slow的，因为fast每次走两个节点，slow每次走一个节点，所以相对速度就是fast以每次一个节点的速度去追slow。

代码

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;
            if(slow==fast){
                ListNode* index1 = fast;
                ListNode* index2 = head;
                while(index1!=index2){
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index2;
            }
        }
        return NULL;
    }
};

今日收获

1.记住了两两交换链表的临时节点记录问题。

2.通过删除链表的倒数节点再一次加深了双指针法的理解。

3.回顾了链表相交的特性。

4.环形链表该题较难，通过该题加深了对环形链表处理的理解。

今日学习时长3h

该文章图片均来自Carl哥的代码随想录，在此特别感谢