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

本文链接：https://blog.csdn.net/weixin_53045504/article/details/128503415

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

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。
你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
在这里插入图片描述

思路·

使用虚拟头结点，这样会方便很多：
在这里插入图片描述

直观

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* tem = cur->next;//记录临时节点
            ListNode* tem1 = cur->next->next->next;//记录临时节点
            cur->next = cur->next->next;//步骤1
            cur->next->next = tem;//步骤2
            cur->next->next->next = tem1;//步骤3
            cur = cur->next->next;//cur移动两位，准备下一轮交换
         }
        //并返回交换后链表的头节点
    return _dummyHead->next;
    }
};

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

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
进阶：你能尝试使用一趟扫描实现吗？
示例 1：
在这里插入图片描述
输入：head = [1,2,3,4,5], n = 2 输出：[1,2,3,5]
输入：head = [1], n = 1 输出：[]
输入：head = [1,2], n = 1 输出：[1]
卡哥思路：
定义fast指针和slow指针，初始值为虚拟头结点，
fast首先走n + 1步，再同时移动，为什么是n+1呢，因为只有这样同时移动的时候，最终slow才能指向删除节点的上一个节，fast指向末尾
在这里插入图片描述

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode *_dummyHead = new ListNode(0);//定义虚拟头节点
        _dummyHead->next = head;
        //定义快慢指针
        ListNode *fast = _dummyHead;
        ListNode *slow = _dummyHead;
        //fast首先走n + 1步,只有这样同时移动的时候slow才能指向删除节点的上一个节点（方便做删除操作）
        for(int i=0 ;i < n+1 ;i++){
            fast = fast ->next;
        }
        //然后fast和slow同时移动，直到fast指向末尾
        while(fast != NULL){
            fast = fast->next;
            slow = slow->next;
        }
        //删除第n个节点
        ListNode* Tem = slow->next ; //把要删除的临时保存     
        slow->next = Tem->next;//释放内存
        delete Tem;
        return _dummyHead->next;
        //return head;不能返回链表头，有可能头也删掉了
    }
};

面试题 02.07. 链表相交：力扣160

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。
要注意，交点不是数值相等，而是指针相等。
在这里插入图片描述输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at ‘8’
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,6,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/intersection-of-two-linked-lists

如下两个链表，目前curA指向链表A的头结点，curB指向链表B的头结点：
在这里插入图片描述
求出两个链表的长度，并求出两个链表长度的差值，然后让curA移动到，和curB 末尾对齐的位置，如图：

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

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

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        //求出两链表长度
        int sizeA = 1;
        int sizeB = 1;
        ListNode *curA = headA;
        ListNode *curB = headB;
        while(headA->next != NULL){
            headA = headA->next;
            sizeA++;
        }
        while(headB->next != NULL){
            headB = headB->next;
            sizeB++;
        }
        // 让curA为最长链表的头，lenA为其长度
        if (sizeB > sizeA) {
            swap (sizeA, sizeB);
            swap (curA, curB);
        }
        // 求长度差
        int chaZhi = sizeA - sizeB;
        // 让curA和curB在同一起点上（末尾位置对齐）
        while (chaZhi--) {
            curA = curA->next;
        }
        //接下来就是两个指针同步移动对比是否相同
          // 遍历curA 和 curB，遇到相同则直接返回
        while (curA != NULL) {
            if (curA == curB) {
                return curA;
            }
            curA = curA->next;
            curB = curB->next;
        }
        return NULL;  
    }
};

142.环形链表II

主要考察两知识点：
判断链表是否环
如果有环，如何找到这个环的入口

a判断链表是否有环

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

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

假设从头结点到环形入口节点的节点数为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同时移动，每次移动一个节点，那么他们相遇的地方就是环形入口的节点。
那么 n如果大于1是什么情况呢，就是fast指针在环形转n圈之后才遇到 slow指针。
其实这种情况和n为1的时候效果是一样的，一样可以通过这个方法找到环形的入口节点，只不过，index1 指针在环里多转了(n-1)圈，然后再遇到index2，相遇点依然是环形的入口节点。

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;//新定义两个节点，来满足X=Z公式
            while(index1 !=index2 ){
                index1 = index1->next;
                index2 = index2->next;
            }//相遇即为入环口
            return index2;//返回入环口
        }//快慢指针相遇一定在环内
        }
        return NULL;//没有环      
    }
};

总结

链表操作中一个非常总要的技巧：虚拟头节
在链表：删除链表倒数第N个节点，怎么删？结合虚拟头结点和双指针法来移除链表倒数第N个节点。删节点记住临时保存，方便释放
链表相交：链表相交使用双指针来找到两个链表的交点（引用完全相同，即：内存地址完全相同的交点）
讲解了在链表如何找环，以及如何找环的入口位置。这道题目可以说是链表的比较难的题目了。但代码却十分简洁，主要在于一些数学证明。
放上代码随想录星球成员：海螺人 (opens new window)，所画，总结的非常好
在这里插入图片描述