算法训练营第四天|24. 两两交换链表中的节点| 19.删除链表的倒数第N个节点| 面试题 02.07. 链表相交| 142.环形链表II-CSDN博客

本文链接：https://blog.csdn.net/Gentea/article/details/131189242

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

这道题目正常模拟就可以了。

建议使用虚拟头结点，这样会方便很多，要不然每次针对头结点（没有前一个指针指向头结点），还要单独处理。

对虚拟头结点的操作，还不熟悉的话，可以看这篇链表：听说用虚拟头节点会方便很多？ (opens new window)。

接下来就是交换相邻两个元素了，此时一定要画图，不画图，操作多个指针很容易乱，而且要操作的先后顺序

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SQAAnGzq-1686641211499)(https://code-thinking.cdn.bcebos.com/pics/24.%E4%B8%A4%E4%B8%A4%E4%BA%A4%E6%8D%A2%E9%93%BE%E8%A1%A8%E4%B8%AD%E7%9A%84%E8%8A%82%E7%82%B91.png)]

操作之后，链表如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-k2YEU1dX-1686641211500)(https://code-thinking.cdn.bcebos.com/pics/24.%E4%B8%A4%E4%B8%A4%E4%BA%A4%E6%8D%A2%E9%93%BE%E8%A1%A8%E4%B8%AD%E7%9A%84%E8%8A%82%E7%82%B92.png)]

看这个可能就更直观一些了：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pDVPTelC-1686641211501)(https://code-thinking.cdn.bcebos.com/pics/24.%E4%B8%A4%E4%B8%A4%E4%BA%A4%E6%8D%A2%E9%93%BE%E8%A1%A8%E4%B8%AD%E7%9A%84%E8%8A%82%E7%82%B93.png)]

/**
 * 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);
        dummyHead->next = head;
        ListNode* cur = dummyHead;

        while(cur->next != nullptr && cur->next->next != nullptr){
            //因为cur在改变指向时是动态的，需要保存指针初始的节点，确保不会丢失
            ListNode* tmp = cur->next;
            ListNode* tmp1 = cur->next->next->next;

            //两两交换操作
            cur->next = tmp->next;
            cur->next->next = tmp;
            cur->next->next->next = tmp1;

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

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

理解一下快慢指针的一种用法：保持窗口大小的情况下，让slow指向正确的位置进行操作，避免遍历两次的时间成本。

定义fast指针和slow指针，初始值为虚拟头结点，如图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oX5ExMQc-1686640831055)(https://code-thinking.cdn.bcebos.com/pics/19.%E5%88%A0%E9%99%A4%E9%93%BE%E8%A1%A8%E7%9A%84%E5%80%92%E6%95%B0%E7%AC%ACN%E4%B8%AA%E8%8A%82%E7%82%B9.png)]

fast首先走n + 1步，为什么是n+1呢，因为只有这样同时移动的时候slow才能指向删除节点的上一个节点（方便做删除操作），如图： [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9dl4ItTS-1686640831065)(https://code-thinking.cdn.bcebos.com/pics/19.%E5%88%A0%E9%99%A4%E9%93%BE%E8%A1%A8%E7%9A%84%E5%80%92%E6%95%B0%E7%AC%ACN%E4%B8%AA%E8%8A%82%E7%82%B91.png)]
fast和slow同时移动，直到fast指向末尾，如题： [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-itll2mKG-1686640831066)(https://code-thinking.cdn.bcebos.com/pics/19.%E5%88%A0%E9%99%A4%E9%93%BE%E8%A1%A8%E7%9A%84%E5%80%92%E6%95%B0%E7%AC%ACN%E4%B8%AA%E8%8A%82%E7%82%B92.png)]
删除slow指向的下一个节点，如图： [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-k0iUEEWB-1686640831066)(https://code-thinking.cdn.bcebos.com/pics/19.%E5%88%A0%E9%99%A4%E9%93%BE%E8%A1%A8%E7%9A%84%E5%80%92%E6%95%B0%E7%AC%ACN%E4%B8%AA%E8%8A%82%E7%82%B93.png)]

此时不难写出如下C++代码：

/**
 * 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);
        //确定虚拟节点位置
        dummyHead->next = head;
        ListNode* fast = dummyHead;
        ListNode* slow = dummyHead;
        

        //控制窗口大小为n+1，使得slow指向正确位置，要删除的n的前一个
        while(n-- && fast != nullptr){
            fast = fast->next;
        }
        //再向前移动一位
        fast = fast->next;
        while(fast != nullptr){
            slow = slow->next;
            fast = fast->next;
        }
        //此时slow指向n-1,开始删除操作
        ListNode* tmp = slow->next;
        slow->next = tmp->next;
        delete tmp;

        return dummyHead->next;  
    }
};

面试题 02.07. 链表相交

简单来说，就是求两个链表交点节点的指针。这里同学们要注意，交点不是数值相等，而是指针相等。

为了方便举例，假设节点元素数值相等，则节点指针相等。

看如下两个链表，目前curA指向链表A的头结点，curB指向链表B的头结点：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8NgvGHFi-1686640831067)(https://code-thinking.cdn.bcebos.com/pics/%E9%9D%A2%E8%AF%95%E9%A2%9802.07.%E9%93%BE%E8%A1%A8%E7%9B%B8%E4%BA%A4_1.png)]

我们求出两个链表的长度，并求出两个链表长度的差值，然后让curA移动到，和curB 末尾对齐的位置，如图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nq9CzxgV-1686640831067)(https://code-thinking.cdn.bcebos.com/pics/%E9%9D%A2%E8%AF%95%E9%A2%9802.07.%E9%93%BE%E8%A1%A8%E7%9B%B8%E4%BA%A4_2.png)]

此时我们就可以比较curA和curB是否相同，如果不相同，同时向后移动curA和curB，如果遇到curA == curB，则找到交点。

否则循环退出返回空指针。

/**
 * 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 lenA = 0;
        int lenB = 0;

        while(curA != NULL){
            lenA++;
            curA = curA->next;
        }

        while(curB != NULL){
            lenB++;
            curB = curB->next;
        }

        //求出长度后再重新指向头部
        curA = headA;
        curB = headB;

        //统一逻辑 求出差值
        if(lenA < lenB){
            swap(lenA,lenB);
            swap(curA,curB);
        }

        //确保A是长链表
        int gap = lenA - lenB;

        //指向长链表与短链表长度一致的部分
        while(gap--){
            curA = curA->next;
        }

        //判断两个指针节点是否一致，而不是数值相同
        while(curA != NULL){
            if(curA == curB){
                return curA;
            }
            curA = curA->next;
            curB = curB->next;
        }
        return NULL;
    }
};

//判断两个指针节点是否一致，而不是数值相同这句话没太理解

这句话的意思是，我们需要判断两个指针节点（链表中的元素）是否相同，而不是它们的数值是否相等。在计算机编程中，链表中的每个元素通常都有一个指针，用于指向下一个元素。所以，在这里，我们关注的是指针本身（地址），而不是它们所指向的数据（数值）。

例如：

相同指针节点：当两个指针指向内存中的完全相同位置时，即使它们的数值/内容不同，也认为这两个指针是相同的。
数值相同：当两个指针指向的数据（数值）相同时，即使它们的内存地址不同，仍然认为它们具有相同的数值。

重点是要理解指针节点的概念，它涉及到内存地址，而不仅仅是数值。

第二种解法

根据题意,两个链表相交的点是指: 该结点既在A链表上又在B链表上,说明A和B是相交的

而对于相交的情况,两条链表一定是这种结构:

为什么呢?
因为如果链表A和链表B相交于D的话,那么说明D结点即在A上又在B上,而D之后的元素自然也就均在A和B上了,因为他们是通过next指针相连的.

如果有相交的结点D的话,每条链的头结点先走完自己的链表长度,然后回头走另外的一条链表,那么两结点一定为相交于D点,因为这时每个头结点走的距离是一样的,都是 AD + BD + DC,而他们每次又都是前进1,所以距离相同,速度又相同,固然一定会在相同的时间走到相同的结点上,即D点

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode *t1 = headA; ListNode *t2 = headB;
        while(t1 != t2){
            if (t1 == NULL)
                t1 = headB;
            else t1 = t1->next;
            if (t2 == NULL)
                t2 = headA;
            else t2 = t2->next;
        }
        return t1;
    }
};

142. 环形链表 II

主要考察两知识点：

判断链表是否环
如果有环，如何找到这个环的入口

#判断链表是否有环

可以使用快慢指针法，分别定义 fast 和 slow 指针，从头结点出发，fast指针每次移动两个节点，slow指针每次移动一个节点，如果 fast 和 slow指针在途中相遇，说明这个链表有环。

为什么fast 走两个节点，slow走一个节点，有环的话，一定会在环内相遇呢，而不是永远的错开呢

首先第一点：fast指针一定先进入环中，如果fast指针和slow指针相遇的话，一定是在环中相遇，这是毋庸置疑的。

那么来看一下，为什么fast指针和slow指针一定会相遇呢？

可以画一个环，然后让 fast指针在任意一个节点开始追赶slow指针。

会发现最终都是这种情况，如下图：

142环形链表1

fast和slow各自再走一步， fast和slow就相遇了

这是因为fast是走两步，slow是走一步，其实相对于slow来说，fast是一个节点一个节点的靠近slow的，所以fast一定可以和slow重合。

动画如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lrQtzver-1686640831068)(https://code-thinking.cdn.bcebos.com/gifs/141.%E7%8E%AF%E5%BD%A2%E9%93%BE%E8%A1%A8.gif)]

#如果有环，如何找到这个环的入口

此时已经可以判断链表是否有环了，那么接下来要找这个环的入口了。

假设从头结点到环形入口节点的节点数为x。环形入口节点到 fast指针与slow指针相遇节点节点数为y。从相遇节点再到环形入口节点节点数为 z。如图所示：

那么相遇时： slow指针走过的节点数为: x + y， fast指针走过的节点数：x + y + n (y + z)，n为fast指针在环内走了n圈才遇到slow指针，（y+z）为一圈内节点的个数A。

因为fast指针是一步走两个节点，slow指针一步走一个节点，所以 fast指针走过的节点数 = slow指针走过的节点数 * 2：

(x + y) * 2 = x + y + n (y + z)

两边消掉一个（x+y）: x + y = n (y + z)

因为要找环形的入口，那么要求的是x，因为x表示头结点到环形入口节点的的距离。

所以要求x ，将x单独放在左面：x = n (y + z) - y ,

再从n(y+z)中提出一个（y+z）来，整理公式之后为如下公式：x = (n - 1) (y + z) + z 注意这里n一定是大于等于1的，因为 fast指针至少要多走一圈才能相遇slow指针。

这个公式说明什么呢？

先拿n为1的情况来举例，意味着fast指针在环形里转了一圈之后，就遇到了 slow指针了。

当 n为1的时候，公式就化解为 x = z，

这就意味着，从头结点出发一个指针，从相遇节点也出发一个指针，这两个指针每次只走一个节点，那么当这两个指针相遇的时候就是环形入口的节点。

也就是在相遇节点处，定义一个指针index1，在头结点处定一个指针index2。

让index1和index2同时移动，每次移动一个节点，那么他们相遇的地方就是环形入口的节点。

动画如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AGndElFE-1686640831069)(https://code-thinking.cdn.bcebos.com/gifs/142.%E7%8E%AF%E5%BD%A2%E9%93%BE%E8%A1%A8II%EF%BC%88%E6%B1%82%E5%85%A5%E5%8F%A3%EF%BC%89.gif)]

那么 n如果大于1是什么情况呢，就是fast指针在环形转n圈之后才遇到 slow指针。

其实这种情况和n为1的时候效果是一样的，一样可以通过这个方法找到环形的入口节点，只不过，index1 指针在环里多转了(n-1)圈，然后再遇到index2，相遇点依然是环形的入口节点。

/**
 * 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* fast = head;
        ListNode* slow = head;
        while(fast != NULL && fast->next != NULL){
            //slow走一步，fast走两步，必然会在环内相遇
            slow = slow->next;
            fast = fast->next->next;

            //相遇的点必然在环内
            if(slow == fast){
                //创建一个index1在相遇点
                //index2从头结点和index1以1步长开始移动，相遇点必然是入口
                //为何相遇点一定是入口，因为x=z，看公式推导
                ListNode* index1 = slow;
                ListNode* index2 = head;
                while(index1 != index2){
                    index1 = index1->next;
                    index2 = index2->next;
                }
                //相遇点即为入口
                return index2;
            }
        }
        return NULL;
    }
};

追赶问题：slow 1步长；fast 2步长

x,y,z的推导

x=z=》index1，index2相遇