挑战刷leetcode第八天（ 链表-环形链表）

lqstyle
233 阅读4分钟

环形链表的奥秘：如何用代码揭开链表的“循环之谜”

你是否曾经想过，链表这种数据结构是否可能像莫比乌斯环一样，首尾相连，形成一个无尽的循环？今天，我们将深入探讨环形链表的检测方法，并用 Java 和 C++ 实现两种经典算法。更重要的是，我们不仅会判断链表是否有环，还会找到环的入口节点——这背后的逻辑和数学原理，绝对会让你大开眼界！

什么是环形链表？

在链表中，每个节点通常指向下一个节点，最后一个节点指向 null，表示链表的结束。但如果某个节点指向了之前的某个节点，链表就会形成一个环，这就是环形链表。

环形链表的存在可能会导致程序陷入无限循环，因此检测链表是否有环是算法面试中的经典问题。接下来，我们将通过两种方法来解决这个问题：

  1. 判断链表是否有环
  2. 找到环的入口节点

方法一：判断链表是否有环

快慢指针法：龟兔赛跑的智慧

我们可以用两个指针来解决这个问题：一个快指针（fast）和一个慢指针（slow）。快指针每次移动两步，慢指针每次移动一步。如果链表中有环，快指针最终会追上慢指针；如果没有环，快指针会到达链表末尾。

Java 实现

public boolean hasCycle(ListNode head) {
    ListNode slow = head;
    ListNode fast = head;

    while (fast != null && fast.next != null) {
        fast = fast.next.next;
        slow = slow.next;
        if (fast == slow) {
            return true;
        }
    }
    return false;
}

C++ 实现

bool hasCycle(ListNode* head) {
    ListNode* fast = head;
    ListNode* slow = head;

    while (fast != nullptr && fast->next != nullptr) {
        fast = fast->next->next;
        slow = slow->next;
        if (fast == slow) {
            return true;
        }
    }
    return false;
}

为什么快慢指针一定能相遇？

假设链表有环，快指针每次比慢指针多走一步，最终一定会追上慢指针。这就像两个人在环形跑道上跑步，速度快的人一定会追上速度慢的人。

方法二：找到环的入口节点

数学推导：环的入口在哪里？

当我们用快慢指针检测到链表有环后，如何找到环的入口节点呢？这里有一个巧妙的数学推导：

  1. 设链表头到环入口的距离为 a，环的长度为 b。

  2. 当快慢指针相遇时，慢指针走了 a + c 步，快指针走了 a + c + n*b 步（n 是快指针在环中绕的圈数）。

  3. 由于快指针的速度是慢指针的两倍，因此有：

    2(a + c) = a + c + n*b

    化简后得到：

    a + c = n*b

    即：

    a = n*b - c

  4. 这意味着，如果我们将一个指针从链表头开始，另一个指针从相遇点开始，它们最终会在环的入口相遇。

Java 实现

public ListNode detectCycle(ListNode head) {
    ListNode slow = head;
    ListNode fast = head;

    while (fast != null && fast.next != null) {
        fast = fast.next.next;
        slow = slow.next;
        if (fast == slow) {
            break;
        }
    }

    if (fast == null || fast.next == null) {
        return null; // 无环
    }

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

C++ 实现

ListNode* detectCycle(ListNode* head) {
    ListNode* slow = head;
    ListNode* fast = head;

    while (fast != nullptr && fast->next != nullptr) {
        fast = fast->next->next;
        slow = slow->next;
        if (fast == slow) {
            break;
        }
    }

    if (fast == nullptr || fast->next == nullptr) {
        return nullptr; // 无环
    }

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

为什么这些算法如此重要？

  1. 面试高频考点：环形链表问题是算法面试中的经典题目，掌握它可以帮助你在面试中脱颖而出。
  2. 实际应用：在内存管理、垃圾回收等领域，检测环形引用是一个重要的任务。
  3. 逻辑思维的锻炼：通过分析快慢指针的行为，我们可以更好地理解指针操作和数学推导的结合。

坚持的意义

作为一名技术博主，我深知学习算法的过程并不容易。但正是这些看似枯燥的代码和逻辑，构成了计算机世界的基石。每当我解决一个算法问题时，都会感受到一种成就感——这不仅是对知识的掌握，更是对自我能力的肯定。

希望通过这篇文章，你能感受到算法的魅力，并在未来的学习和工作中，勇敢面对每一个挑战。记住，坚持的意义不在于一时的成功，而在于每一次的进步和成长。

思考题：如果链表中存在多个环，上述算法还能正常工作吗？为什么？欢迎在评论区分享你的想法！

avatar
文章
阅读
粉丝