Linked List Cycle - Practice Coding Problems

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.

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?

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.

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
✓ Hash Set Tracking	O(n)	O(n)	Use a hash set to track visited nodes in O(1) lookup time
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
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

Hash Set Tracking — Algorithm Steps

Initialize an empty hash set to store visited nodes
Start traversal from head node
For each node, check if it's already in the hash set
If found in set, return true (cycle detected)
If not found, add the node to the hash set
Move to the next node
If we reach null, return false (no cycle)

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize hash set

Start with empty set and begin at head

Check and add

For each node, check set in O(1) time, then add current node

Instant detection

Hash set immediately identifies when we revisit a node

Code -

solution.c — C

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

// Simple hash table implementation for demonstration
#define HASH_SIZE 10007
struct ListNode* hashTable[HASH_SIZE];

int hash(struct ListNode* node) {
    return ((long)node % HASH_SIZE);
}

bool hasCycle(struct ListNode *head) {
    if (!head) return false;
    
    // Clear hash table
    for (int i = 0; i < HASH_SIZE; i++) {
        hashTable[i] = NULL;
    }
    
    struct ListNode* current = head;
    
    while (current) {
        int idx = hash(current);
        
        // Simple linear probing
        while (hashTable[idx] != NULL) {
            if (hashTable[idx] == current) {
                return true;
            }
            idx = (idx + 1) % HASH_SIZE;
        }
        
        hashTable[idx] = current;
        current = current->next;
    }
    
    return false;
}

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

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

Constraints

Visualization

Related Problems

Common Approaches

Hash Set Tracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler