代码随想录算法训练营第4天|LeetCode24.两两交换链表中的节点、LeetCode19.删除链表的倒数第N个结点、LeetCode面试题02.07.链表相交、LeetCode142.环形链表||

代码随想录算法训练营第4天|LeetCode24.两两交换链表中的节点、LeetCode19.删除链表的倒数第N个结点、LeetCode面试题 02.07. 链表相交、LeetCode142.环形链表II

1、LeetCode24.两两交换链表中的节点

题目：24. 两两交换链表中的节点 - 力扣（LeetCode）
文章：代码随想录 (programmercarl.com)
视频：帮你把链表细节学清楚！ | LeetCode：24. 两两交换链表中的节点_哔哩哔哩_bilibili

解题思路

（这题直接先看了视频）
要想操作某两个节点，cur必须在这两个节点之前。

cur初始值：dummy，因为要操作第一个和第二个。

重点：

• 遍历的终止条件
• 两两交换的逻辑

结束遍历：

• 偶数：cur->为空。包括了空链表。
• 奇数：cur->next->next为空，如图上奇数节点的情况，最后一个不用交换。
• while(cur->next !=null && cur->next->next != null)条件的顺序不可变，否则可能出现空指针错误——cur->next为空，再next就报错。

交换的逻辑：
先保存->按图中①②③的顺序->移动cur。
注意：

• ①操作的时候会丢失节点1，因此需要提前保存。
• ②操作的时候会丢失节点3，提前保存。
• 因此最开始先保存，再后续 操作

代码

犯错：

• dummy初始化漏了dummy->next = head;
• temp2赋值成第二个节点了
• 忘记更新cur值

ListNode* swapPairs(ListNode* head) {
        ListNode* dummy = new ListNode();
        //不要忘记这一步！！
        dummy->next = head;
        ListNode* cur = dummy;
        while(cur->next != nullptr && cur->next->next != nullptr){//顺序很重要
            //先保存
            ListNode* temp1 = cur->next;
            ListNode* temp2 = cur->next->next->next;//注意这里保存的是第三个节点
            cur->next = cur->next->next;
            //这时候cur->next已经改变
            cur->next->next = temp1;
            temp1->next = temp2;
            //不要忘记更新cur！！！
            cur = cur->next->next;
        }
        return dummy->next;
    }

2、LeetCode19.删除链表的倒数第N个结点

题目：19. 删除链表的倒数第 N 个结点 - 力扣（LeetCode）
文章：代码随想录 (programmercarl.com)
视频：链表遍历学清楚！ | LeetCode：19.删除链表倒数第N个节点_哔哩哔哩_bilibili

第一想法

要删除倒数第n个，那么cur遍历的时候就要到达这个节点的前一个。怎么到达：或许可以先翻转再正着来…

解题思路

我的思路完全不对。。。

双指针：
fast先跑n个，然后fast和slow一起跑直到fast为null时，slow指向要被删除的元素。

但是要删除这个元素需要指向其前一个元素，因此fast先跑n+1，这样slow就指向前一个了，然后删除。

删除的逻辑可以看看前几天的文章。

代码

犯错：写快了返回值直接写的dummy

    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummy = new ListNode();
        dummy->next = head;
        ListNode* fast=dummy;
        ListNode* slow = dummy;
        //fast移动n+1步
        n++;
        while(n--){
            fast = fast->next;
        }
        //快慢同时移动
        while(fast){
            fast = fast->next;
            slow = slow->next;
        }
        //进行删除操作
        ListNode* temp = slow->next;
        slow->next = temp->next;
        delete temp;//回收
        return dummy->next;

    }

3、LeetCode面试题 02.07. 链表相交

题目：面试题 02.07. 链表相交 - 力扣（LeetCode）
文章：代码随想录 (programmercarl.com)
视频：无

第一想法

时间不够直接看题解。
看了题解之和发现自己理解的题目意思有误，以为是两个链表相交的节点，即只要有一个相等，后面分叉也无所谓。（题目的图没认真看！！！）

结果不是的，是在一个节点处两个链表汇合了。

解题思路

首先注意：值相等！=节点相等。

1. 对齐：计算两个链表的长度，计算差，长的链表的指针先移动，直到两个链表指针对齐。
2. 找相等：两个指针同时往后移，如果相等则返回当前指针。

代码

    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* curA = headA;
        ListNode* curB = headB;
        int lenA=0;
        int lenB=0;
        //数个数
        while(curA){
            lenA++;
            curA = curA->next;
        }
        while(curB){
            lenB++;
            curB = curB->next;
        }
        curA = headA;
        curB = headB;
        //长的先移动
        if(lenA>lenB){
            int gap = lenA - lenB;
            while(gap--){
                curA = curA->next;
            }
        }
        else{
            int gap = lenB - lenA;
            while(gap--){
                curB = curB->next;
            }
        }
        //现在是相同起点
        while(curA){
            if(curA == curB){
                return curA;
            }
            curA = curA->next;
            curB = curB->next;
        }
        return NULL;

注意：在对齐-“长的先移动”的时候，我用if-else进行处理，让代码看起来更长了，可以用以下代码替换

// 让curA为最长链表的头，lenA为其长度
        if (lenB > lenA) {
            swap (lenA, lenB);
            swap (curA, curB);
        }
        // 求长度差
        int gap = lenA - lenB;
        // 让curA和curB在同一起点上（末尾位置对齐）
        while (gap--) {
            curA = curA->next;
        }

4、LeetCode142.环形链表II

题目：142. 环形链表 II - 力扣（LeetCode）
文章：代码随想录 (programmercarl.com)
视频：把环形链表讲清楚！ 如何判断环形链表？如何找到环形链表的入口？ LeetCode：142.环形链表II_哔哩哔哩_bilibili

第一想法

不会。。。只能想到找变量记下来是否再次访问，如果再次访问说明有环并为起点。

解题思路

两个考点：是否有环+环的入口
（不懂请看b站视频！！！）

1是否有环

思路：双指针，快慢指针如果相遇则说明有环。如果链表无环，是个直线，那么快慢指针不可能相遇。除非有圈，快指针先进去绕圈，慢指针后面再进去绕圈儿，他们就会相遇。

实际上就是：快指针追赶慢指针的节点过程。

why：定义快指针一次走两个节点，慢指针一次走一个节点，那么在环中，快指针相较于慢指针在以2-1=1个单位进行追赶，总能追赶到。但如果快指针相较于慢指针在以2个单位进行追赶，那么就有可能跳过慢指针。

2环的入口

思路：
如图所示定义变量x，y，z，

可以由快慢指针的速度得到相遇时等式
slow = x+y
fast = x+y+n(y+z)，n表示快指针已经在圈里转了n圈
2(x+y) = x+y+n(y+z)

整理得x = n(y+z)-y, n>=1，快指针至少转了一圈与慢指针相遇（因为快指针是“追”慢指针）
想看x和什么整数有关系
变形得x = (n-1)(y+z)+z

若n=1，则x=z。说明从头结点出发一个指针，从相遇节点 也出发一个指针，这两个指针每次只走一个节点， 那么当这两个指针相遇的时候就是 环形入口的节点。

若n>1，说明快指针在环中转了n圈之和才遇到慢指针。这种情况和n=1一样，只不过index1 指针在环里 多转了(n-1)圈，然后再遇到index2，相遇点依然是环形的入口节点。

动画

代码

    ListNode *detectCycle(ListNode *head) {
        ListNode* fast = head;
        ListNode* slow = head;
        //因为fast一次走2，所以next也要判断
        while(fast != NULL && fast->next != NULL) {
            slow = slow->next;
            fast = fast->next->next;
            // 重要！！快慢指针相遇，此时从head 和 相遇点，同时查找直至相遇
            if (slow == fast) {
	            //两个index用来找环的起始
                ListNode* index1 = fast;
                ListNode* index2 = head;
                while (index1 != index2) {
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index2; // 返回环的入口
            }
        }
        return NULL;
    }