Day 4 24. 两两交换链表中的节点 19.删除链表的倒数第N个节点面试题 02.07. 链表相交 142.环形链表II 总结-CSDN博客

本文链接：https://blog.csdn.net/qq_46025584/article/details/136977023

24. 两两交换链表中的节点 19.删除链表的倒数第N个节点面试题 02.07. 链表相交 142.环形链表II 总结

交换相邻节点

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

示例 1：

输入：head = [1,2,3,4]
输出：[2,1,4,3]

画图，注意区分空指针和死循环的问题：

/**
 * 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* CurrNode = DummyHead;
        while(CurrNode->next != NULL && CurrNode->next->next != NULL){//此处一定是先判断cur->next！
            ListNode* temp1 = CurrNode->next;//记录此时节点1的位置
            ListNode* temp2 = CurrNode->next->next->next;//记录此时节点3的位置
            CurrNode->next = CurrNode->next->next;//虚拟头节点指向节点2，此时节点2已经变成了cur->next
            CurrNode->next->next = temp1;//节点2指向节点1，此时节点1的地址变为cur->next->next
            CurrNode->next->next->next = temp2;//节点1指向节点3
            CurrNode = CurrNode->next->next;//cur后移两位
        }
        return DummyHead->next;
    }
};

删除倒数第n个节点

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

示例 1：

输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]

经典双指针题目了：

/**
 * 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* FastPtr = DummyHead;
        ListNode* SlowPtr = DummyHead;
        SlowPtr->next = head;
        n++;//因为处理倒数第n个节点，所以要求慢指针走到倒数第n个结点的前一个结点
        while(n-- && FastPtr != NULL){
            FastPtr = FastPtr->next;
        }
        while(FastPtr){
            FastPtr = FastPtr->next;
            SlowPtr = SlowPtr->next;
        }
        ListNode* TempNode = SlowPtr->next;
        SlowPtr->next = SlowPtr->next->next;
        delete TempNode;
        return DummyHead->next;
    }
};

链表相交

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

图示两个链表在节点 c1 开始相交**：**

题目数据保证整个链式结构中不存在环。

注意，函数返回结果后，链表必须 保持其原始结构 。

示例 1：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at '8'
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

注意此处链表的相交节点指的是相等的指针

/**
 * 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, lenB = 0;
        while (curA != NULL) { // 求链表A的长度
            curA = curA->next;
            lenA++;
        }
        while (curB != NULL) { // 求链表B的长度
            curB = curB->next;
            lenB++;
        }
        curA = headA;
        curB = headB;//重置curA、curB的位置到头节点
        // 让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;
    }   
};

环形链表II

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

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。

示例 1：

输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 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) {
        ListNode* FastPtr = head;
        ListNode* SlowPtr = head;
        while(FastPtr != NULL && FastPtr->next !=NULL){
            FastPtr = FastPtr->next->next;
            SlowPtr = SlowPtr->next;
            if(FastPtr == SlowPtr){
                ListNode* Index1 = FastPtr;
                ListNode* Index2 = head;
                while(Index1 != Index2){
                    Index1 = Index1->next;
                    Index2 = Index2->next;
                }
                return Index1;
            }
        }
        return NULL;

    }
};

总结

1.最重要的思路：虚拟头指针，可以大幅减少循环时因为头节点的存在而不得不分开讨论的繁琐；但是一定要记住使用虚拟头节点时，采取的CurrNode遍历指针指向的是DummyHead还是DummyHead->next(也就是真正的头节点)，如果使用不恰当很容易造成代码功能异常，特别是涉及到对第n个元素进行操作时，一定要记住是将CurrNode指向第n-1个元素；

2.反转链表，再次相遇迭代思想，从本科开始就一直折磨没学懂的东西，现在看起来似乎有了一点豁然开朗的感觉了：从最基本的迭代法看起，个人把其想象成一根很长的绳子以相同办法包装一个结果，最后这个绳子的结构看起来越来越复杂，但最终只要解开那个绳结，所有的结也都全部解开；

碎碎念：算是打卡第一周？这周也是发生了很多事，跟着同门去唱k（虽然真的不会唱只是当个背景板）撸串，周五晚上被导师拉着开了一个乌龙组会，压力也是一下就上来了，不过是真的不想学雷达啊，真费脑子啊；哦，至于研究生课程？没啥用，没听啊，不知道啊，卡尔哥没说啊。