Codestin Search App

Linked List Cycle - Problem

Imagine you're following a chain of connected nodes, where each node points to the next one. But what if this chain secretly loops back on itself? 🔄

Given the head of a linked list, your mission is to detect if there's a cycle - meaning you could theoretically follow the next pointers forever and end up visiting the same node again.

What makes this tricky? You can't see the entire structure at once, and you don't know where the cycle might begin (if it exists). You can only follow the next pointers one by one.

Return true if there's a cycle, false otherwise.

Note: The parameter pos mentioned in examples is just for illustration - it's not actually passed to your function.

Input & Output

example_1.py — Cycle exists

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

› Output: true

💡 Note: There is a cycle where the tail connects back to the 1st node (0-indexed). The last node (-4) points back to the second node (2), creating a loop.

example_2.py — Simple cycle

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

› Output: true

💡 Note: There is a cycle where the tail connects back to the 0th node. The second node (2) points back to the first node (1).

example_3.py — No cycle

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

› Output: false

💡 Note: There is no cycle in the linked list. A single node with no next pointer cannot form a cycle.

Visualization

Tap to expand

Circular Track: Fast runner will eventually lap the slow runnerLinear Track: Fast runner reaches the finish line first💡 Key Insight: If pointers meet → cycle exists, if fast reaches null → no cycle⚡ Efficiency: O(n) time, O(1) space - no extra storage needed!

Understanding the Visualization

Start the Race

Both runners start at the same position (head of linked list)

Different Paces

Slow runner takes 1 step, fast runner takes 2 steps each turn

Two Outcomes

Either fast runner reaches finish line (no cycle) or catches slow runner (cycle found)

Key Takeaway

🎯 Key Insight: Floyd's algorithm elegantly solves cycle detection with constant space by leveraging the mathematical property that two pointers at different speeds will always meet in a cycle.

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each node exactly once, and hash set operations are O(1) on average

✓ Linear Growth

Space Complexity

O(n)

In worst case (no cycle), we store all n nodes in the hash set

⚡ Linearithmic Space

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) memory?

Asked in

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

The optimal solution uses Floyd's Cycle Detection Algorithm (tortoise and hare) with two pointers moving at different speeds. The slow pointer moves one step at a time while the fast pointer moves two steps. If there's a cycle, the fast pointer will eventually catch up to the slow pointer, achieving O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Every Node)	O(n²)	O(n)	Visit each node and check if we've seen it before by searching through all previously visited nodes
Floyd's Cycle Detection (Tortoise and Hare)	O(n)	O(1)	Use two pointers moving at different speeds - if there's a cycle, the fast pointer will catch the slow one
Hash Set Tracking	O(n)	O(n)	Use a hash set to track visited nodes in O(1) lookup time

Brute Force (Check Every Node) — Algorithm Steps

Start from head and maintain a list of visited nodes
For each current node, check if it exists in our visited list
If found, return true (cycle detected)
If not found, add current node to visited list
Move to next node and repeat
If we reach null, return false (no cycle)

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at head

Begin traversal with empty visited list

Check and add

For each node, search through visited list, then add current node

Cycle found

When we encounter a node we've seen before, cycle is detected

Code -

solution.c — C

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

bool hasCycle(struct ListNode *head) {
    if (!head) return false;
    
    struct ListNode* visited[10000]; // Assuming max 10000 nodes
    int visitedCount = 0;
    struct ListNode* current = head;
    
    while (current) {
        // Check if current node is already in visited array
        for (int i = 0; i < visitedCount; i++) {
            if (visited[i] == current) {
                return true;
            }
        }
        
        visited[visitedCount++] = current;
        current = current->next;
    }
    
    return false;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we potentially search through up to n-1 previously visited nodes

⚠ Quadratic Growth

Space Complexity

O(n)

We store all visited nodes in a list, which can be up to n nodes

⚡ Linearithmic Space

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) memory?

89.7K Views

Very High Frequency

~15 min Avg. Time

2.8K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Check Every Node) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler