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

一. LeetCode24. 两两交换链表中的节点

题目链接/文章讲解/视频讲解：  https://programmercarl.com/0024.%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%B9.html

状态：已解决

1.思路 

        这道题我卡了很久，主要是之前少思考了一个数据交换的操作，想清楚交换两个节点一共需要进行几次数据交换，这道题就变得很简单了。

   （1）数据交换个数   

对于头节点，交换相邻的节点需要经过两个数据交换的步骤。但是，对于非头节点的节点交换：

需要经过三个数据交换的步骤，具体原因是因为其他节点还要经历：上一个节点的上一个节点指向自己（即步骤①）的过程。因此，为了统一步骤，应增加一个我们熟悉的老朋友“虚拟节点”。

这样对所有两两相邻的节点都可以设置三次数据交换。

（2）具体交换策略：

        因为涉及到要改变待交换两个节点的前一个节点的指向，因此cur必须从前一个节点开始，实现①需：cur->next = cur->next->next，但由于③都需要用到原本的cur->next（值为1的节点）和，因此必须事先保存cur->next，又由于②需要用到①交换完的cur->next->next(值为3的节点)，但是②做完后cur->next->next指向了节点1，因此必须事先保存节点值为3的节点。

（3）循环结束条件：

        cur代表待交换两个节点的前一个节点（也就是上轮处理完的两个节点的后一个），因此每次循环结束，都要将cur往后移动2位（变成新的待交换节点的前一个节点）。故为了保障每次移位都能实现，循环条件应该为：cur->next != nullptr && cur->next->next != nullptr，注意顺序不能反过来，否则如果cur->next为空，那么先判断cur->next->next就会出错。

2.代码实现

（1）我的代码：

        我用了两个指针，一个代表待处理两个节点的前一个节点，一个代表待处理节点的第一个节点，指针数量变多了但反而让代码变得复杂，尤其是对边界值的判断，因此不建议看这版，很复杂。

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode * dummy = new ListNode(0);
    	dummy->next = head; 
        ListNode * cur = head;
        ListNode * pre = dummy;
        //cur->val,cur->next->val,cur->next->next->val,;;
        while(cur != NULL && cur->next != NULL && cur->next->next != NULL){ 
        	ListNode * temp = cur;
		    cur = cur->next;
		    pre->next = cur;
			temp->next = cur->next;
			cur->next = temp;
	        pre = temp;
	        cur = temp->next;
        }
        if(cur != NULL && cur->next != NULL){
        	ListNode * temp = cur;
        	cur = cur->next;
        	pre->next = cur;
        	cur->next = temp;
        	temp->next = nullptr;
		}
        return dummy->next;
    }
};

---

 

（2）视频解法：

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummyHead = new ListNode(0); // 设置一个虚拟头结点
        dummyHead->next = head; // 将虚拟头结点指向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; // cur移动两位，准备下一轮交换
        }
        return dummyHead->next;
    }
};

时间复杂度：O(n)

空间复杂度：O(1)

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

题目链接/文章讲解/视频讲解： 

https://programmercarl.com/0019.%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.html

状态：已解决

1.思路

        这道题我的最初想法是先扫一遍，得到链表长度，再遍历链表sz-n次，就可以得到倒数第n个节点的上一个节点的地址，然后将上一个节点直接指向下下个节点即可。但看了视频解析后，发现该题还有更简单的解法——双指针

大致思路：快指针先走，慢指针离快指针n个节点，这样当快指针扫到null（链表结尾）时，与它相距n个节点的慢指针自然也就是倒数第n个节点了。

理论如此，但实际实现有一些细节：

        slow指针初始应该指向dummy（虚拟头节点），fast指向head节点，然后再让fast移动n步，这样slow与fast之间的距离就是n+1了。

        为什么是n+1不是n？举个例子就好懂了。

        因为是删除节点，我们需要用到待删除节点的上一个节点，因此slow代表的应该是待删节点的上一个节点，待删节点离fast指针n个节点远，那么待删节点的上一个节点离fast就应该n+1个节点远。

2.代码实现

        理清楚具体逻辑，代码就很好写了：

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode * dummy = new ListNode(0);
        dummy->next = head;
        ListNode * slow = dummy;
        ListNode * fast = head;
        while(n--){
            fast = fast->next;
        }
        while(fast != nullptr){
            fast = fast->next;
            slow = slow->next;
        }
        ListNode * temp = slow->next;
        slow->next = temp->next;
        delete temp;
        return dummy->next;
    }
};

时间复杂度：O(n)

空间复杂度：O(1) 

 三. 面试题 02.07. 链表相交

题目链接/文章讲解/视频讲解：https://programmercarl.com/%E9%9D%A2%E8%AF%95%E9%A2%9802.07.%E9%93%BE%E8%A1%A8%E7%9B%B8%E4%BA%A4.html

状态：已解决

1.思路

        这题拿到第一眼我又重复了之前的思维错误，想从两个链表的尾部往头部遍历，如果有重复值就一直向前遍历下去，直到两个链表此时的节点并不相等，分叉点的下一个节点就是初始相交节点，但单向链表无法从下一个节点转到上一个节点，因此只能PASS掉这个想法。看了视频发现这道题也没想的那么复杂 。

大致思路：先分别扫描两个链表，然后求出两个链表的长度，再让长的链表先移动到与短的链表齐平的节点，然后二者同时开始扫描，直到扫描到节点相等的地方（地址相等，不是值相等）。

原因：因为有交叉点交叉的必定是在长链表与短链表长度相对的部分。

如图，交叉点必然在长链表[6，5，4，2]片段之间。如果出现在这个片段之前，则从相交节点开始，长链表的相交长度必定大于短链表的相交长度，不符合题意（从相交节点到尾部都属于相交部分）。

2.代码实现

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        int lenA=0,lenB=0;
        ListNode * curA = headA;
        ListNode * curB = headB;
        while(curA != nullptr){
            curA = curA->next;
            lenA++;
        }
        while(curB != nullptr){
            curB = curB->next;
            lenB++;
        }

        ListNode * startA = headA;
        ListNode * startB = headB;
        int lenD = lenA-lenB;
        if(lenD > 0){
            while(lenD--){
                startA = startA->next;
            }
        }
        else{
            lenD = -lenD;
            while(lenD--){
                startB = startB->next;
            }
        }

        while(startA !=nullptr && startA != startB ){
            startA = startA->next;
            startB = startB->next;
        }
        return startA;
    }
};

时间复杂度：O(m+n)

空间复杂度：O(1)

四. LeetCode 142.环形链表II 

题目链接/文章讲解/视频讲解：https://programmercarl.com/0142.%E7%8E%AF%E5%BD%A2%E9%93%BE%E8%A1%A8II.html

状态：已解决

1.思路 

        这道题我没有想出来，看了视频和文章讲解才有了想法，这居然是一个小学奥数学的追逐问题。

此题有两个重点：

（1）判断链表是否有环

（2）如果有环，找到环的入口

针对（1），使用双指针，从头节点开始，每次循环，慢指针只走一步，而快指针则走两个节点，如果有环，快指针一定会追上慢指针（小学奥数的环形操场同向追逐问题）。用物理学的相对运动理解，以慢指针为参考物，快指针一直在以一个节点的速度靠近慢指针的，如果有环快指针必定能够追上慢指针。如图。

针对（2），可以用数学知识来解决：

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

        相遇时，slow指针走过的节点数为: x + y， fast指针走过的节点数：x + y + n (y + z)，n为fast指针在环内走过的圈数。因为fast指针是一步走两个节点，slow指针一步走一个节点， 所以 fast指针走过的节点数 = slow指针走过的节点数 * 2，也就是：(x + y) * 2 = x + y + n (y + z)，化简得x = (n - 1) (y + z) + z （n>=1）因为快者追上慢者总是在快者领先于慢者几圈的情况下实现的。

        （补：为什么slow走过的节点数只能是x+y，而不是x+m*(y+z)+y？很简单，假如slow在圈中走完一圈才和fast相遇，那就说明slow在圈中至少走了y+z个节点，而以刚刚说的相对运动的思想去看，当slow走了y+z个节点时，fast也相对于slow走了y+z个节点，也就是fast相对于slow走了一圈，二者相差了整整一圈。无论slow最初离fast多远，也远不了一圈的距离，因此fast总能在这圈内追上slow。

        将这个公式代入图形，可以惊讶地发现假如让slow指针重新回到头节点，再让fast指针从相遇节点开始继续走下去，这次二者都是一次走一个节点，那么它们会在环形入口处相遇。因此，当fast和新slow指针相等时，就可以找到环形入口的位置了。

2.代码实现

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode * slow = head;
        ListNode * fast = head;
        int flag = 0;
        while(slow != fast || flag == 0){
            flag = 1;
            if(slow == nullptr || fast->next == nullptr || fast->next->next == nullptr){
                return nullptr;
            }
            slow = slow->next;
            fast = (fast->next)->next;
        }

        slow = head;
        while(slow != fast){
            slow = slow->next;
            fast = fast->next;
        }
        return slow;
    }
};

时间复杂度：O(n)（根据上述分析可知对于slow来说肯定走不到两圈，因此走的次数整体小于2n）

空间复杂度：O(1)