Detect Cycle in Linked List Floyd's Algorithm in DSA Javascript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this code detecting a cycle in a linked list?

Consider a linked list with nodes 1 -> 2 -> 3 -> 4 -> 5, where node 5 points back to node 3, creating a cycle. What will the function print?

DSA Javascript

class Node {
  constructor(value) {
    this.value = value;
    this.next = null;
  }
}

function hasCycle(head) {
  let slow = head;
  let fast = head;
  while (fast && fast.next) {
    slow = slow.next;
    fast = fast.next.next;
    if (slow === fast) {
      return true;
    }
  }
  return false;
}

// Create nodes
const head = new Node(1);
head.next = new Node(2);
head.next.next = new Node(3);
head.next.next.next = new Node(4);
head.next.next.next.next = new Node(5);
// Create cycle: node 5 points to node 3
head.next.next.next.next.next = head.next.next;

console.log(hasCycle(head));

A true

B undefined

C false

D TypeError

💡 Hint

Think about what happens when fast and slow pointers meet in a cycle.

The fast pointer moves two steps and the slow pointer moves one step. Because of the cycle, they will eventually meet, so the function returns true.

❓ Predict Output

intermediate

What is the output when the linked list has no cycle?

Given a linked list 1 -> 2 -> 3 -> 4 -> 5 with no cycle, what will the function print?

DSA Javascript

class Node {
  constructor(value) {
    this.value = value;
    this.next = null;
  }
}

function hasCycle(head) {
  let slow = head;
  let fast = head;
  while (fast && fast.next) {
    slow = slow.next;
    fast = fast.next.next;
    if (slow === fast) {
      return true;
    }
  }
  return false;
}

// Create nodes
const head = new Node(1);
head.next = new Node(2);
head.next.next = new Node(3);
head.next.next.next = new Node(4);
head.next.next.next.next = new Node(5);

console.log(hasCycle(head));

A true

B ReferenceError

C false

D null

💡 Hint

No cycle means fast pointer will reach the end.

Since there is no cycle, the fast pointer reaches the end (null) and the function returns false.

🧠 Conceptual

advanced

Why does Floyd's algorithm use two pointers moving at different speeds?

What is the main reason Floyd's cycle detection algorithm uses a slow pointer moving one step and a fast pointer moving two steps?

A To sort the linked list nodes while detecting the cycle

B To detect if the fast pointer reaches the end faster than the slow pointer

C To reduce the memory usage by using two pointers instead of a hash set

D To ensure the pointers meet inside the cycle if one exists

💡 Hint

Think about how the pointers behave inside a cycle.

The fast pointer moves faster and will eventually catch up to the slow pointer inside the cycle, confirming a cycle exists.

❓ Predict Output

advanced

What is the output of this code with a single node cycle?

A linked list has one node that points to itself, creating a cycle. What will the function print?

DSA Javascript

class Node {
  constructor(value) {
    this.value = value;
    this.next = null;
  }
}

function hasCycle(head) {
  let slow = head;
  let fast = head;
  while (fast && fast.next) {
    slow = slow.next;
    fast = fast.next.next;
    if (slow === fast) {
      return true;
    }
  }
  return false;
}

const head = new Node(1);
head.next = head; // cycle to itself

console.log(hasCycle(head));

A true

B null

C false

D RangeError

💡 Hint

A node pointing to itself forms a cycle.

Since the node points to itself, the slow and fast pointers meet immediately, so the function returns true.

🔧 Debug

expert

What error does this code raise?

This code attempts to detect a cycle but has a bug. What error will it raise when run?

DSA Javascript

class Node {
  constructor(value) {
    this.value = value;
    this.next = null;
  }
}

function hasCycle(head) {
  let slow = head;
  let fast = head;
  while (fast && fast.next && fast.next.next) {
    slow = slow.next;
    fast = fast.next.next;
    if (slow === fast) {
      return true;
    }
  }
  return false;
}

const head = new Node(1);
head.next = new Node(2);
head.next.next = new Node(3);

console.log(hasCycle(head));

A ReferenceError

B TypeError

C false

D true

💡 Hint

Check the while loop condition for null safety.

The code does not check if fast is null before accessing fast.next, so if fast is null, accessing fast.next causes a TypeError.

Practice

1. What is the main purpose of Floyd's Cycle Detection Algorithm in a linked list?

easy

A. To reverse the linked list

B. To sort the linked list in ascending order

C. To find the middle element of the linked list

D. To check if the linked list contains a cycle or loop

Solution

1. Step 1: Understand Floyd's Algorithm goal

   Floyd's Cycle Detection Algorithm is designed to detect if a linked list has a cycle, meaning a node points back to a previous node.

2. Step 2: Compare with other linked list operations

   Sorting, reversing, or finding the middle element are different operations and not the purpose of this algorithm.

3. Final Answer:

   To check if the linked list contains a cycle or loop -> Option D

4. Quick Check:

   Detect cycle = Check loop presence [OK]

Hint: Floyd's algorithm detects loops, not sorting or reversing [OK]

Common Mistakes:

• Confusing cycle detection with sorting
• Thinking it finds the middle node
• Assuming it reverses the list

2. Which of the following is the correct way to initialize the two pointers in Floyd's Cycle Detection Algorithm in JavaScript?

easy

A. let slow = null; let fast = head;

B. let slow = head; let fast = head;

C. let slow = head; let fast = head.next;

D. let slow = head.next; let fast = head.next.next;

Solution

1. Step 1: Understand pointer initialization

   Slow pointer starts at head, fast pointer starts at head.next to allow fast to move two steps safely.

2. Step 2: Check pointer positions

   Starting fast at head.next prevents immediate equality and helps detect cycles correctly.

3. Final Answer:

   let slow = head; let fast = head.next; -> Option C

4. Quick Check:

   Slow at head, fast at head.next [OK]

Hint: Initialize slow at head and fast at head.next to detect cycles properly [OK]

Common Mistakes:

• Starting both pointers at head causing immediate equality
• Initializing slow pointer as null
• Starting pointers at incorrect nodes

3. Consider the following JavaScript code using Floyd's Algorithm to detect a cycle in a linked list:

function hasCycle(head) {
  let slow = head;
  let fast = head;
  while (fast && fast.next) {
    slow = slow.next;
    fast = fast.next.next;
    if (slow === fast) {
      return true;
    }
  }
  return false;
}

// Linked list: 1 -> 2 -> 3 -> 4 -> 2 (cycle back to node with value 2)

What will be the output of hasCycle(head)?

medium

A. Runtime error

B. true

C. undefined

D. false

Solution

1. Step 1: Understand the linked list structure

   The list has a cycle because node with value 4 points back to node with value 2.

2. Step 2: Trace Floyd's Algorithm behavior

   Slow moves one step, fast moves two steps; they will meet inside the cycle, so function returns true.

3. Final Answer:

   true -> Option B

4. Quick Check:

   Cycle present = true [OK]

Hint: If pointers meet, cycle exists, so return true [OK]

Common Mistakes:

• Assuming no cycle returns true
• Confusing pointer equality with value equality
• Ignoring fast pointer null checks

4. The following code attempts to detect a cycle in a linked list using Floyd's Algorithm but has a bug:

function detectCycle(head) {
  let slow = head.next;
  let fast = head.next.next;
  while (fast && fast.next) {
    if (slow === fast) return true;
    slow = slow.next;
    fast = fast.next.next;
  }
  return false;
}

What is the main issue with this code?

medium

A. It does not check if head is null before accessing next

B. It starts slow and fast pointers ahead, missing cycles at head

C. It compares values instead of nodes for equality

D. It moves slow pointer two steps instead of one

Solution

1. Step 1: Analyze pointer initialization

   Code sets slow = head.next and fast = head.next.next without checking if head or head.next exist.

2. Step 2: Identify potential runtime error

   If head is null or head.next is null, accessing next properties causes runtime error.

3. Final Answer:

   It does not check if head is null before accessing next -> Option A

4. Quick Check:

   Missing null check causes runtime error [OK]

Hint: Always check head and next before pointer initialization [OK]

Common Mistakes:

• Ignoring null checks causing runtime errors
• Starting pointers incorrectly but missing null checks
• Confusing node equality with value equality

5. You have a linked list where a cycle exists, but you want to find the node where the cycle begins using Floyd's Algorithm. Which additional step should you perform after detecting the cycle?

hard

A. Reset one pointer to head, then move both pointers one step at a time until they meet

B. Continue moving fast pointer two steps and slow pointer one step until fast reaches null

C. Reverse the linked list and check for repeated nodes

D. Count the number of nodes in the list and divide by two

Solution

1. Step 1: Detect cycle using Floyd's Algorithm

   When slow and fast pointers meet, a cycle is confirmed.

2. Step 2: Find cycle start node

   Reset slow pointer to head, then move slow and fast one step at a time; their meeting point is the cycle start.

3. Final Answer:

   Reset one pointer to head, then move both pointers one step at a time until they meet -> Option A

4. Quick Check:

   Reset and move pointers to find cycle start [OK]

Hint: Reset slow to head, move both pointers stepwise to find cycle start [OK]

Common Mistakes:

• Continuing fast pointer movement after cycle detection
• Trying to reverse list to find cycle start
• Using node count to find cycle start incorrectly