【刷题专栏—突破思维】142. 环形链表 II

在这里插入图片描述

前言：本篇博客将讲解三个OJ题，前两个作为铺垫，最后完成环形链表的节点的寻找

文章目录

一、160. 相交链表
二、141. 环形链表
三、142. 环形链表II

一、160. 相交链表

题目链接：LeetCode—相交链表

题目描述：
给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。
图示两个链表在节点 c1 开始相交：

注意，函数返回结果后，链表必须保持其原始结构。
评测系统将根据这些输入创建链式数据结构，并将两个头节点 headA 和 headB 传递给你的程序。如果程序能够正确返回相交节点，那么你的解决方案将被视作正确答案。

示例1：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at ‘8’
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。

示例2：

输入：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 。

题目解析:

遍历链表计算长度：初始化两个指针curA和curB分别指向链表headA和headB的头节点，然后遍历链表，分别计算链表的长度lenA和lenB，来到尾节点时比较是否一致，一致说明链表相交；否则，不相交，即可返回NULL。
对齐起点：如果尾节点相同，计算两个链表长度的差值n，然后选取较长链表的头节点为longList，较短链表的头节点为shortList。然后，将longList指针向后移动n个位置，使得两个链表剩余长度相等。
寻找交点：同时遍历longList和shortList，找到它们第一个相同的节点，即为交点。

代码实现：

typedef struct ListNode ListNode;
struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    ListNode* curA = headA, *curB = headB;
    // 初始化链表headA和headB的长度分别为1，原因是curA和curB初始化就指向头
    int lenA = 1, lenB = 1;

    // 计算链表headA的长度
    while (curA->next) {
        lenA++;
        curA = curA->next;
    }

    // 计算链表headB的长度
    while (curB->next) {
        lenB++;
        curB = curB->next;
    }

    // 如果链表headA和headB的尾节点不相同，说明它们没有交点，返回NULL
    if (curA != curB) {
        return NULL;
    }

    //abs 函数是 C 语言标准库（<stdlib.h> 头文件）中的一个函数，用于返回整数的绝对值
    int n = abs(lenA - lenB);
    // 初始化指针longList和shortList，分别指向较长和较短的链表头部
    ListNode* longList = headA, *shortList = headB;

    // 如果链表headA较短，调整longList和shortList的指向
    if (lenA < lenB) {
        longList = headB;
        shortList = headA;
    }

    // 将较长链表指针向后移动，使两个链表剩余长度相等
    while (n--) {
        longList = longList->next;
    }

    // 同时移动长链表和短链表指针，直到找到交点
    while (longList != shortList) {
        longList = longList->next;
        shortList = shortList->next;
    }

    // 返回交点（如果存在）
    return longList;
}

二、141. 环形链表

题目链接：LeetCode—环形链表

题目描述：
给你一个链表的头节点 head ，判断链表中是否有环。
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。
注意：pos 不作为参数进行传递。仅仅是为了标识链表的实际情况。
如果链表中存在环，则返回 true 。否则，返回 false 。

示例 1：

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

示例 2：

输入：head = [1,2], pos = 0
输出：true
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

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

题目解析：
这是经典的快慢指针算法用于检测链表中是否存在环。算法的核心思想是使用两个指针，一个移动速度较慢（每次移动一步），另一个移动速度较快（每次移动两步）。如果链表中存在环，快指针最终会追上慢指针，导致它们相遇。

在遍历过程中，如果快指针能够追上慢指针，就说明存在环。如果没有相遇，而是快指针达到链表的末尾（为NULL），则链表是无环的。

这种算法的时间复杂度为 O(N)，其中 N 是链表的长度。这是因为在最坏情况下，快指针将遍历整个链表一次。

代码实现：

typedef struct ListNode ListNode;
bool hasCycle(struct ListNode *head) {
    // 初始化两个指针，slow每次移动一步，fast每次移动两步
    ListNode* slow = head;
    ListNode* fast = head;

    // 遍历链表，直到fast为NULL或fast的下一个节点为NULL
    while (fast != NULL && fast->next != NULL) {
        // slow前进一步
        slow = slow->next;
        // fast前进两步
        fast = fast->next->next;

        // 如果存在环，slow和fast会在某个时刻相遇
        if (slow == fast) {
            // 存在环，返回true
            return true;
        }
    }

    // 遍历完成，没有相遇，说明链表无环
    return false;
}

思考问题：快慢指针的速度有要求吗，会不会存在快指针和慢指针不相遇的情况。

首先说结论，只要有速度差，都可以相遇。

想象一下，快慢指针相遇时，它们在环内，且快指针比慢指针多走了n个环，C是环的大小，我们令快指针的速度为a，慢指针的速度为b。

假设快慢指针走k步，它们相遇。又因为相遇时，快指针比慢指针多走了n个环。我们可以得到 $(a - b) k = n C$ 。

我们从题中得知a-b和C，k和n是未知数。易知一定存在整数k和整数n使得等式成立。得出结论，快慢指针一定能在环内相遇。

三、142. 环形链表II

题目链接：LeetCode—环形链表II
经过前两题的铺垫，这题的思路更容易打开了

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

示例 1：

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

示例 3：

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

题目解析：

判断是否有环： 快指针速度设为2，慢指针设为1（为了找入环节点必须这样设置，下面会阐述原因），无环直接返回NULL。

找入环节点： 快指针速度设为2，慢指针设为1的原因在这，想象一下，在极端情况下，快慢指针同时从入环节点出发（可以看作快指针与慢指针相距一个环的距离）。这种情况下，慢指针走了半环，快指针走了一个环；接着慢指针走完剩下半个环来到入环点，这时快指针又走了一个环来到入环点。快慢指针在入环节点相遇了。

在实际情况下，快指针一定先入环，接着慢指针从头节点到达入环节点，这时快慢指针的距离一定小于或等于环。那么可想而知，它们相遇时，慢指针最多走完一次环，快指针在从慢指针入环到它们相遇时也最多走完两次环。我们设相遇时距离入环节点为X，C时环的大小（X<=C）。

相遇时有等式 $2 (L + X) = L + n * C + X$ （快指针的路程=L+从头节点到相遇时走了n次环+X，慢指针的路程=L+X）。化简得 $L = (n - 1) * X + C - X$ ,从公式中我们可以看出，当我们走完L（到达入环节点），等于从距离入环节点的X处开始走，可以走（n-1）次环加上C-X（到达入环节点）。

因此，用两个相同速度的指针，一个从头节点开始走，另一个从相遇点开始走，最终会在入环节点相遇。
在这里插入图片描述
代码实现：

typedef struct ListNode ListNode;

struct ListNode *detectCycle(struct ListNode *head) {
    // 初始化两个指针，slow每次移动一步，fast每次移动两步
    ListNode* slow = head;
    ListNode* fast = head;

    // 遍历链表，直到fast为NULL或fast的下一个节点为NULL
    while (fast && fast->next) {
        // slow前进一步
        slow = slow->next;
        // fast前进两步
        fast = fast->next->next;

        // 如果存在环，slow和fast会在某个时刻相遇
        if (slow == fast) {
            // 相遇点保存在meet中，从链表头开始和meet同时移动，直到再次相遇，即为环的起点
            ListNode* meet = slow;
            while (head != meet) {
                head = head->next;
                meet = meet->next;
            }
            // 返回环的起点
            return meet;
        }
    }

    // 遍历完成，没有相遇，说明链表无环
    return NULL;
}