24暑假算法刷题 | Day4 | LeetCode 24. 两两交换链表中的节点，19. 删除链表的倒数第N个节点，面试题 02.07. 链表相交，142. 环形链表 II

---

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

点此跳转题目链接

题目描述

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

示例 1：

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

示例 2：

输入：head = []
输出：[]

示例 3：

输入：head = [1]
输出：[1]

提示：

• 链表中节点的数目在范围 [0, 100] 内
• 0 <= Node.val <= 100

题解

采用前后双指针解决：前指针在后指针的下一个位置，每次交换两个指针的值、两个指针同时前进两位，直到链表结尾。

代码（C++）

ListNode *swapPairs(ListNode *head)
{
    // 思路：双指针
    if (!head || !head->next)
        return head;
    
    ListNode *former = head->next, *later = head;
    swap(former->val, later->val);
    while (former->next && former->next->next) {
        former = former->next->next;
        later = later->next->next;
        swap(former->val, later->val);
    }
    return head;
}

---

19. 删除链表的倒数第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]

提示：

• 链表中结点的数目为 sz
• 1 <= sz <= 30
• 0 <= Node.val <= 100
• 1 <= n <= sz

进阶： 你能尝试使用一趟扫描实现吗？

题解

最简单直接的思路显然是：先遍历一次，得出链表长度，再从头节点开始走（总长-倒数位置）的长度即可。这样相当于要扫描两遍，下面给出一趟扫描的解法：

采用前后双指针，前指针先走 n + 1 步，然后两个指针开始以单位速度前进，前指针走到链表结尾空节点时，后指针恰好指向待删除节点的前驱节点，于是可以进行删除。

前指针先走n步的话，后指针会恰停在待删除节点上，则无法删除。

代码（C++）

ListNode *removeNthFromEnd(ListNode *head, int n)
{
    // 思路：双指针，快指针先走 n + 1 步，然后快慢指针一起走
    // 快指针走到链表末尾空指针处时，慢指针恰好位于倒数第n个节点的前驱
    ListNode *dummyHead = new ListNode(0, head);
    ListNode *fast = dummyHead, *slow = dummyHead;
    for (int i = 0; i < n + 1; i++)
        fast = fast->next;
    while (fast) {
        slow = slow->next;
        fast = fast->next;
    }
    slow->next = slow->next->next;
    return dummyHead->next;
}

更详细的讲解参见代码随想录 (programmercarl.com)。

---

面试题 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 。

提示：

• listA 中节点数目为 m
• listB 中节点数目为 n
• 0 <= m, n <= 3 * 104
• 1 <= Node.val <= 105
• 0 <= skipA <= m
• 0 <= skipB <= n
• 如果 listA 和 listB 没有交点，intersectVal 为 0
• 如果 listA 和 listB 有交点，intersectVal == listA[skipA + 1] == listB[skipB + 1]

进阶： 你能否设计一个时间复杂度 O(n) 、仅用 O(1) 内存的解决方案？

题解

一个简单的思路是用哈希集合，把两条链的节点逐个加入，直到遇到已存在的，则说明是相交节点：

ListNode *getIntersectionNode_BySet(ListNode *headA, ListNode *headB)
{
    // 用一个set存储a链节点
    set<ListNode *> nodeSet;
    while (headA || headB)
    {
        if (headA)
        {
            if (nodeSet.find(headA) != nodeSet.end())
                return headA;
            nodeSet.insert(headA);
            headA = headA->next;
        }
        if (headB)
        { // 检查b链节点是否已在集合（a链）中出现过
            if (nodeSet.find(headB) != nodeSet.end())
                return headB;
            nodeSet.insert(headB);
            headB = headB->next;
        }
    }
    return nullptr;
}

下面考虑不用其他容器的方法。受到题目示例图的影响可以发现，由于相交节点之后的链表是公共的，所以若有相交，则应该先把两条链的尾端对齐。然后再各用一个指针同步向后遍历，遇到相同的指针则是相交节点。

代码（C++）

ListNode *getIntersectionNode(ListNode *headA, ListNode *headB)
{
    // 先找出长链
    ListNode *curA = headA, *curB = headB;
    int lenA = 0, lenB = 0;
    while (curA) {
        lenA++;
        curA = curA->next;
    }
    while (curB) {
        lenB++;
        curB = curB->next;
    }
    // 将两条链的尾端对齐（方法：长链指针先走 长度差 个节点）
    curA = headA, curB = headB;
    if (lenA > lenB) {
        int dist = lenA - lenB;
        for (int i = 0; i < dist; i++)
            curA = curA->next;
    } else {
        int dist = lenB - lenA;
        for (int i = 0; i < dist; i++)
            curB = curB->next;
    }
    // 开始检查有无相同节点
    while (curA && curB)
    {
        if (curA == curB)
            return curA;
        curA = curA->next, curB = curB->next;
    }
    return nullptr;
}

---

142. 环形链表 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
解释：链表中没有环。

提示：

• 链表中节点的数目范围在范围 [0, 104] 内
• -105 <= Node.val <= 105
• pos 的值为 -1 或者链表中的一个有效索引

进阶： 你是否可以使用 O(1) 空间解决此题？

题解

这题第一次做的时候想了一段时间没想出什么巧妙的方法，遂又采用集合存节点的暴力解法：

ListNode *detectCycle(ListNode *head)
{
    // 思路：利用哈希集合，遇到重复结点则返回
    unordered_set<ListNode*> nodeSet;
    while (head) {
        if (nodeSet.find(head) != nodeSet.end())
            return head;
        nodeSet.insert(head);
        head = head->next;
    }
    return nullptr;
}

但其实通过我们可以推导一下，发现其中的有趣规律，从而不用其他容器，以 $O(1)$ 的空间复杂度解决。

采用快慢双指针，从起点开始，慢指针一次前进一个节点、快指针一次前进两个节点。如果快指针先遇到空节点，则显然该链表无环；否则，快慢指针第一次相遇的位置必定是在环内。

为什么若有环则两个指针一定会相遇：快指针入环前，始终在慢指针前面；两指针都入环后，快指针相当于以1个节点/次的相对速度（这个速度也是单位速度）追慢指针，所以肯定能相遇（想象操场跑步套圈）。

下面借助卡哥的图开始推导：

首先我们把所有情况统一为：快指针 fast 在环里面走了一圈后，在走第二圈过程中第一次遇到了入环的慢节点 slow 。

如果 $x$ 很长、环不太长，易知快指针可能在环里面转了若干圈才“等”到慢指针。但是“快指针多转的圈长”和“同一时间内慢指针在直链上走的长度”显然可以“抵消”，这完全不影响后续推导。

两个指针第一次相遇时，由于这之前 fast 的速度是 slow 的两倍，其路程也是 slow 的两倍。所以由上图可得：
$$x+(y+z)+y=2(x+y)$$
化简可得：
$$x=z$$
而 $x$ 正是我们需要的：从头节点到环入口的长度。所以初遇后，让 slow 回到头节点，然后两个指针都以单位速度前进，下一次相遇时必是在环入口节点（ slow 走了 $x$ ， fast 走了 $z$ ，相等）。

代码（C++）

ListNode *detectCycle(ListNode *head)
{
    // 思路：双指针，快指针一次走两个节点，慢指针一次走一个节点
    ListNode *fast = head, *slow = head;
    while (fast && fast->next) {
        fast = fast->next->next;
        slow = slow->next;
        if (fast == slow) {
            // 相遇后，慢指针回到链表起点，两个指针以单位速度前进，再次相遇位置就是环的起点
            slow = head;
            while (slow != fast) {
                slow = slow->next;
                fast = fast->next;
            }
            return fast;
        }
    }
    return nullptr;
}

更详细的推导可参考代码随想录 (programmercarl.com)。