Linked List Cycle II - Practice Coding Problems

Linked List Cycle II - Problem

Imagine you're following a series of connected rooms, where each room has an arrow pointing to the next room. You suspect there might be a loop - a sequence of rooms that eventually leads back to a room you've already visited!

Given the head of a linked list, your mission is to find the exact node where the cycle begins. If there's no cycle, return null.

Important: You cannot modify the linked list structure, and you must solve this efficiently!

Example: If you have a linked list 3 → 2 → 0 → -4 and the last node -4 points back to node 2, then the cycle begins at node 2.

Input & Output

example_1.py — Basic Cycle

$ Input: head = [3,2,0,-4], pos = 1

› Output: Node with value 2

💡 Note: The linked list is 3 → 2 → 0 → -4, and the tail connects back to the node with value 2 (at position 1). The cycle starts at the second node.

example_2.py — Self Loop

$ Input: head = [1,2], pos = 0

› Output: Node with value 1

💡 Note: The linked list is 1 → 2, and the tail connects back to the first node (position 0). The cycle starts immediately at the head.

example_3.py — No Cycle

$ Input: head = [1], pos = -1

› Output: null

💡 Note: There is only one node and no cycle exists (pos = -1 indicates no cycle), so we return null.

Constraints

The number of nodes in the list is in the range [0, 10⁴]
-10⁵ ≤ Node.val ≤ 10⁵
pos is -1 or a valid index in the linked list
Follow-up: Can you solve it using O(1) constant memory?

Visualization

Tap to expand

Understanding the Visualization

Start the Race

Both runners start at the same point. Slow runner takes 1 step, fast runner takes 2 steps.

They Meet!

If there's a loop, the fast runner will eventually catch up to the slow runner inside the loop.

Find the Loop Start

Reset one runner to start. Now both move at same speed. Where they meet is the loop beginning!

Key Takeaway

🎯 Key Insight: Floyd's algorithm leverages the mathematical relationship between pointer speeds and cycle geometry to find the cycle start in optimal time and space complexity.

Asked in

a Amazon 45 ⊞ Microsoft 38 G Google 32 f Meta 28 Apple 22

The optimal solution uses Floyd's Cycle Detection Algorithm with two pointers moving at different speeds. When they meet, we use the mathematical property that the distance from head to cycle start equals the distance from meeting point to cycle start. This achieves O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Previous Nodes)	O(n²)	O(1)	For each node, check if it appears earlier in the list
Hash Set (Visit Tracking)	O(n)	O(n)	Track visited nodes in a hash set, return first revisited node
Floyd's Cycle Detection (Two Pointers)	O(n)	O(1)	Use fast and slow pointers to detect cycle, then find the start mathematically

Brute Force (Check All Previous Nodes) — Algorithm Steps

Start from the head of the linked list
For each node, traverse from head again to check if current node was seen before
If we find the current node in our previous traversal, that's the cycle start
If we reach null, there's no cycle

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at head

Begin traversal from the head node

Check previous nodes

For current node, scan all previous nodes to see if current appears earlier

Repeat process

Continue this process for each node until cycle is found or end is reached

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

// Definition for singly-linked list node
struct ListNode {
    int val;
    struct ListNode *next;
};

struct ListNode* detectCycle(struct ListNode *head) {
    if (!head || !head->next) return NULL;
    
    struct ListNode* current = head;
    while (current) {
        struct ListNode* checker = head;
        while (checker != current) {
            if (checker == current->next) {
                return current->next;
            }
            checker = checker->next;
        }
        current = current->next;
    }
    
    return NULL;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we potentially check up to n previous nodes

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few pointer variables, no extra data structures

✓ Linear Space

68.0K Views

High Frequency

~25 min Avg. Time

2.9K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Check All Previous Nodes) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler