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

● Leetcode24 两两交换链表中的节点

题目链接：Leetcode24 两两交换链表中的节点
视频讲解：代码随想录|两两交换链表中的节点
题目描述：给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。
示例 1：

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

● 解题思路

思路：
借助dummyhead完成第一组结点的交换，之后再两两交换结点，直到完成所有结点的交换。

时间复杂度： O(n) 空间复杂度： O(1)

● 注意事项

循环终止条件

·偶数个数终止条件： 当完成最后一组结点的交换时，退出循环之后cur->next为nullptr，结束交换。

·奇数个数终止条件： 当能够配对的结点完成交换之后，剩余最后一个结点没有与之配对直接退出循环，此时cur->next->next为nullptr，循环退出。

因此，在while循环内的循环退出条件为cur->next != nullptr && cur->next->next != nullptr。如果误将循环条件写成cur->next->next != nullptr && cur->next != nullptr时，当结点个数为偶数时，cur->next已经为nulptr，因此对于cur->next->next而言会发生空指针异常。

循环异常：

如果代码运行出现循环异常，则是在交换交换结点之前没有保存当前组的第一个结点或者下一组的第一个结点，导致丢失了对其中结点的访问，无法正常进行交换。
当未使用tmp1保存当前组第一个结点时，如图所示：

当未使用tmp2保存下一组第一个结点时，如图所示：

● 代码实现

/**
 * 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; //借助dummyhead方便删除操作
        ListNode* cur = dummyhead;
        while(cur->next && cur->next->next)
        {
            ListNode* tmp1 = cur->next; //当前组的第一个结点
            ListNode* tmp2 = cur->next->next->next; //下一组的第一个结点

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

            cur = cur->next->next; //移动到下一组的前一个结点
        }
        return dummyhead->next;
    }
};

● Leetcode19 删除链表的倒数第N个节点

题目链接：Leetcode19 删除链表的倒数第N个节点
视频讲解：代码随想录|删除链表的倒数第N个节点
题目描述：给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
示例 1：

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

● 解题思路

计算链表长度： 借助自定义计算链表长度的函数获得链表长度之后，在删除倒数第n个结点函数内直接寻找目标结点完成删除既可。

时间复杂度： O(n) 空间复杂度： O(1)

fast/slow双指针： 让fast指针先移动n+1个结点，然后使fast和slow指针一同移动直到fast == nullptr，此时的slow正好为删除结点的前一个结点，再进行删除操作。

时间复杂度： O(n) 空间复杂度： O(1)

● 代码实现

计算链表长度：

/**
 * 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:
    int getLength(ListNode* head)
    {
        int ans = 0;
        while(head)
        {
            ans++;
            head = head->next;
        }
        return ans;
    }
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyhead = new ListNode(0, head);
        int loop = getLength(head) - n;
        ListNode* cur = dummyhead;
        while(loop--)
        {
            cur = cur->next;
        }
        ListNode* tmp = cur->next;
        cur->next = cur->next->next;
        delete tmp;
        head = dummyhead->next;
        delete dummyhead;
        return head;
    }
};

fast/slow双指针：

/**
 * 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, head);
        ListNode *fast = dummyhead, *slow = dummyhead;

        n++; //防止n>链表长度时，进行空指针操作
        while(n--)
        {
            fast = fast->next;
        }

        //当fast为nullptr时，slow恰好为删除结点的前一个结点
        while(fast)
        {
            fast = fast->next;
            slow = slow->next;
        }

        //删除目标结点
        ListNode *tmp = slow->next;
        slow->next = slow->next->next;
        delete tmp;

        head = dummyhead->next;
        return head;
    }
};

● Leetcode面试题 02.07. 链表相交

题目链接：Leetcode面试题 02.07. 链表相交
题目描述：给你两个单链表的头节点 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 个节点。
示例 2：

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

输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。
由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
这两个链表不相交，因此返回 null 。

● 解题思路

首先我们需要理解题目中求交点结点，最后的结果是指针相同的结点，而非数值相同的结点。开始我以为两个链表是分别独立的，相交结点理解为数值相同，对于这类仍需要考虑在数值相交相同后的结点是否都相同的情况。
但对于本题而言不需要考虑那么多，只需要我们获取两个链表的长度之后，将相交结点之前的结点尾部对其，循环寻找指针相同的结点即可。如图所示：

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

● 代码实现

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

        //计算A的长度
        while(curA)
        {
            lenA++;
            curA = curA->next;
        }
        //计算B的长度
        while(curB)
        {
            lenB++;
            curB = curB->next;
        }

        //重置curA和curB到链表head处
        curA = headA, curB = headB;

        //让链表A始终为最长链表，减少分情况讨论
        if(lenB > lenA)
        {
            swap(curA, curB);
            swap(lenA, lenB);
        }

        //获取两者的长度查，对其两个链表的尾端
        int gap = lenA - lenB;
        while(gap--)
        {
            curA = curA->next;
        }

        //遍历curA 和 curB，遇到相同则直接返回
        while(curA)
        {
            if(curA == curB)
            {
                return curA;
            }
            curA = curA->next;
            curB = curB->next;
        }
        return nullptr;
    }
};

● Leetcode142 环形链表II

题目链接：Leetcode142 环形链表II
视频讲解：代码随想录|环形链表II|环形链表
题目描述：给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。
不允许修改 链表。
示例 1：

输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。
示例 2：

输入：head = [1,2], pos = 0
输出：返回索引为 0 的链表节点
解释：链表中有一个环，其尾部连接到第一个节点。
示例 3：

输入：head = [1], pos = -1
输出：返回 null
解释：链表中没有环。

● 解题思路

首先，我们需要判断链表是否有环，如果不存在环返回nullptr；
然后在确定存在环的基础上，寻找链表中环的入口并将其返回。

时间复杂度： O(n) 空间复杂度： O(1)

● 判断是否有环

使用双指针fast和slow判断是否有环。让fast每次移动两个结点，slow每次移动一个结点。假如链表不存在环，即链表是直的时候，fast和slow以一快一慢的速率是不可能相遇的。
如果fast和slow能够相遇，即证明环的存在。因为当fast和slow都进入环的时候，fast总比slow快一个结点，相当于fast以一个结点的速度接近于slow，两者必定相遇。如图所示：

● 寻找环的入口

设head到入口的距离为x，入口到相遇结点距离为y，相遇结点到入口距离为z。

对于slow走过的结点为x+y，fast走过的结点为x+n(y+z)。因为fast指针是一步走两个节点，slow指针一步走一个节点， 所以 fast指针走过的节点数 = slow指针走过的节点数 * 2：2(x+y) = x+y+n(y+z) ,化简移项最后得到：x = (n - 1) (y + z) + z。当n = 1时，可得x = z，即意味着从头结点出发一个指针，从相遇节点 也出发一个指针，这两个指针每次只走一个节点， 那么当这两个指针相遇的时候就是 环形入口的节点。 定义index1为相遇结点，index2为头结点，循环每次每个移动一个结点，相遇处即为环的入口。

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

我们还需要考虑，为什么slow走过的距离为x+y而不写成x+y+k(y+z)呢？
首先可以肯定的是，slow进入环的时候，fast肯定在环中。基于s= vt，对此我们将若干个环展开分情况进行讨论：
（1）因为fast的速度是slow的2倍，所以在相同的时间内fast的路程会是slow的2倍。当fast第二次经过入口，此时slow刚好到达入口时，必定会在第三个入口时再次相遇。此时，fast走了两圈，slow走了一圈。

此时的x为slow从开始到进入环的距离，y在该情况下为一个环的距离，也是从入口到相遇点的距离，与上述所设相同。

（2）当slow经过入口时，fast位于环中某一个位置时。
设此时fast到入口距离为k，环总长为n。当fast走到第三个入口时总距离为k+n，则此时slow总距离为(k+n)/2。因为k < n，所以(k+n) / 2 < n，则在整个过程中fast和slow在slow的第一圈内必定相遇过。

该情况下，x仍为slow从开始到进入环的距离，y为从入口到两者相遇点的距离。仍未x+y，与上述所设相同。

综上所述，slow在从开始运动到相遇点的距离恒为x+y。

● 代码实现

/**
 * 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, *slow = head;
        //判断是否有环
        while(fast && fast->next)
        {
            fast = fast->next->next;
            slow = slow->next;

            //相遇结点
            if(fast == slow)
            {
                ListNode *index1 = fast, *index2 = head;

                //寻找入口
                while(index1 != index2)
                {
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index1;
            }
        }
        return nullptr;
    }
};