Linked List Cycle LeetCode Solution: Complete Walkthrough

Linked List Cycle (#141) is one of those problems that every serious interview candidate encounters. It is a gateway to one of the most elegant algorithms in computer science: Floyd's Tortoise and Hare cycle detection. Once you understand it, you unlock a pattern that applies far beyond linked lists.

The linked list cycle LeetCode problem asks a deceptively simple question — does this linked list contain a cycle? But the real challenge is answering it in O(1) space, which is exactly what interviewers want to see. This walkthrough covers both the intuitive hash set approach and the optimal Floyd's algorithm.

Whether you are preparing for FAANG interviews or building your fundamentals, this problem teaches you the fast slow pointer pattern that appears in dozens of other problems. Let's break it down step by step.

Given the head of a linked list, determine if the list has a cycle. A cycle exists when some node's next pointer connects back to a previously visited node, creating an infinite loop. If you tried to traverse to the end, you would never reach null.

The input includes a pos parameter (used only for test case generation) indicating which node the tail connects to. Your function receives only the head node — you do not have access to pos. You must return true if a cycle exists, false otherwise.

This problem is classified as Easy on LeetCode, but it introduces concepts that are foundational for Medium and Hard linked list problems. The follow-up question — detecting where the cycle starts — is LeetCode #142, a Medium problem that builds directly on this one.

The most intuitive approach to detect a cycle in a linked list is using a hash set. As you traverse the list, store each visited node in the set. If you encounter a node that is already in the set, you have found a cycle. If you reach null, the list is cycle-free.

This approach works perfectly and is easy to implement. You simply iterate through the list, checking membership in the set at each step. The moment you see a duplicate, return true. If the traversal ends at null, return false.

The time complexity is O(n) since you visit each node at most once. The space complexity is also O(n) because in the worst case you store every node in the set before detecting the cycle or reaching the end. This is where the follow-up challenge comes in — can you do better on space?

Floyd's cycle detection algorithm is the optimal solution for the linked list cycle LeetCode problem. The idea is beautifully simple: use two pointers moving at different speeds. The slow pointer (tortoise) moves one step at a time, while the fast pointer (hare) moves two steps at a time.

If there is no cycle, the fast pointer will reach the end of the list (null) and you return false. If there is a cycle, the fast pointer will eventually lap the slow pointer — they will meet at the same node. When they meet, you return true.

The implementation is remarkably concise. Initialize both pointers at the head. In each iteration, advance slow by one node and fast by two nodes. Check if they point to the same node. That is the entire algorithm — four lines of logic that solve the problem optimally.

The time complexity is O(n). In the worst case, the slow pointer traverses the entire list. The space complexity is O(1) — you only use two pointer variables regardless of the list size. This is what makes Floyd's algorithm superior to the hash set approach.

The mathematical intuition behind Floyd's algorithm is elegant. If there is a cycle, once both pointers enter the cycle, the fast pointer gains exactly one step on the slow pointer per iteration. Think of it like two runners on a circular track — the faster runner will inevitably lap the slower one.

Let's think about it more precisely. Once both pointers are inside the cycle, the distance between them decreases by one with each iteration. Since the fast pointer gains one position per step, the gap shrinks from whatever it was down to zero. They must meet within at most one full traversal of the cycle.

If there is no cycle, the fast pointer simply races ahead and hits null. It can never "lap" the slow pointer because there is no loop to circle back through. This is why the null check on fast and fast.next is sufficient — it guarantees termination in the acyclic case.

This proof extends to any cycle length and any tail length before the cycle. The relative speed difference of 1 ensures convergence regardless of the specific structure. It is one of those rare algorithms where the proof is as clean as the code.

Before submitting, consider the edge cases. An empty list (head is null) has no cycle — return false immediately. A single node with no self-loop also has no cycle. A single node whose next points to itself is the simplest possible cycle. Your implementation handles all of these if you check fast and fast.next correctly.

The natural follow-up is LeetCode #142, Linked List Cycle II, which asks you to find the node where the cycle begins. This requires Floyd's "phase 2": after the slow and fast pointers meet inside the cycle, reset one pointer to the head. Then advance both pointers one step at a time. The node where they meet again is the start of the cycle.

This phase 2 trick works because of a mathematical property: the distance from the head to the cycle start equals the distance from the meeting point to the cycle start (traveling around the cycle). Understanding this elevates your grasp of pointer manipulation from practical to theoretical.

Linked List Cycle (#141) is a gateway to the fast/slow pointer pattern, which is one of the most versatile techniques in algorithm interviews. The same two-pointer approach helps you find the middle of a linked list (#876), detect palindrome linked lists (#234), and even solve the Happy Number problem (#202) — which has nothing to do with linked lists at all.

The deeper lesson is that pointer manipulation problems reward understanding over memorization. If you understand why Floyd's algorithm works, you can derive it on the spot. If you just memorize the code, you will struggle when the interviewer tweaks the problem. This is exactly the kind of pattern recognition that YeetCode flashcards are designed to reinforce.

Add Linked List Cycle to your review rotation. Practice recognizing when a problem involves cycle detection or the fast/slow pointer pattern. Once this technique becomes second nature, a whole category of linked list and mathematical problems opens up to you.