LeetCode 141: Linked List Cycle — Python Solution

Solve LeetCode 141: Linked List Cycle in Python with a Floyd cycle detection approach. The key is to make the state invariant explicit, so the implementation and complexity follow naturally.

This guide paraphrases the task and does not reproduce LeetCode’s prompt. Use the official page for the complete statement, examples, constraints, and submission runner.

DifficultyEasy
TopicLinked List
Reusable patternFloyd cycle detection
ComplexityO(n) time and O(1) extra space

What the problem is testing

Advance one pointer by one node and another by two. They meet exactly when the reachable list contains a cycle.

Algorithm

  1. Advance one pointer by one node and another by two. They meet exactly when the reachable list contains a cycle.
  2. Maintain this invariant: After k steps the fast pointer has moved twice as far as the slow pointer modulo any cycle.
  3. Continue until every input item or reachable state has been resolved, then return the accumulated result.

Python solution

LeetCode provides the list, tree, or graph node definition used by the method.

from collections import Counter, defaultdict, deque, OrderedDict
import random

class Solution:
    def hasCycle(self, head):
        slow = fast = head
        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
            if slow is fast:
                return True
        return False

Why this is correct

The proof follows the maintained state: After k steps the fast pointer has moved twice as far as the slow pointer modulo any cycle. Each iteration preserves that claim while permanently resolving at least one position, node, interval, or search state. When the loop or recursion ends, every candidate required by the problem has therefore been included or ruled out, so the returned value is correct.

Complexity

O(n) time and O(1) extra space. The stated auxiliary space excludes the returned output unless the output is the data structure being built.

Edge cases

An empty list or one node without a self-loop has no cycle.

Tested reference code

This implementation is included in the site’s downloadable 100-solution Python library. The complete suite compiles every solution and runs a behavioral assertion for every problem before publication.


Browse the searchable 100 LeetCode Python Solutions hub. Previous: 224. Basic Calculator · Next: 2. Add Two Numbers