Fast and Slow Pointers Pattern

When to use Fast and Slow Pointers

• You need to detect whether a linked list, sequence, or implicit functional graph contains a cycle.
• You need to find the middle node of a singly linked list in one pass without computing its length first.
• You need to find the entry point of a cycle once one is detected.
• You need to detect a happy number, fixed point, or any repeating sequence under a deterministic transition function.
• You cannot use extra space proportional to the input (so a visited-set approach is disqualified).

Template

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

Common mistakes

• Advancing fast by `fast.next.next` without first checking that `fast.next` is non-null, which throws a null reference on even-length lists.
• Returning the meeting point as the cycle start; the meeting point and cycle entry differ by a head-start that you must re-walk from the head.
• Using slow == fast as a starting condition (both begin at head), which would immediately return true on the first iteration.
• Choosing this pattern when the input is not a singly linked sequence and a hash set would be both simpler and equally fast.
• Forgetting that the middle-finding template returns the upper-middle on even-length lists by default — adjust the loop if you want the lower-middle.