Check if a Linked List is Circular

The problem. Given the head of a singly linked list, return true if it is circular — its last node points back to the head instead of to null — and false otherwise. An empty list is not circular. (A list whose last node points back into the middle is a different problem: Linked List Cycle.)

Example

1 -> 2 -> 3 -> 4 -> (back to 1)    ->  true
1 -> 2 -> 3 -> 4 -> null           ->  false
5 -> (back to 5)                   ->  true
empty list                         ->  false

The pattern: circular linked lists

A circular list has no null to stop at. Every algorithm on one needs a different stopping rule — usually "we're back where we started" — and that's where most circular-list bugs come from: a loop written for a normal list runs forever. The questions in this chapter all turn on that idea: detecting the ring, using a ring on purpose (Rotate List closes one and cuts it), keeping a ring sorted, and simulating turn-taking round a circle.

Here the stopping rule decides the answer. Walk from the head: if you reach null, the list has an end; if you come back to the head, it's circular. With the guarantee that any loop goes back to the head, one of the two must happen within n steps.

1. Remember every node you've seen

Without trusting any guarantee, keep a set of visited nodes. The first node you meet twice tells you where the loop goes; the list is circular only if that node is the head.

1function isCircular(head) {2  const seen = new Set();3  for (let curr = head; curr !== null; curr = curr.next) {4    if (seen.has(curr)) return curr === head;   // the first node seen twice decides it5    seen.add(curr);6  }7  return false;                                  // reached null: the list has an end8}

Time O(n), space O(n). It even handles a loop back into the middle (answering false), but it pays for a set as big as the list.

2. Walk until null or back at the head

1function isCircular(head) {2  if (head === null) return false;     // an empty list has no ring3  let curr = head.next;4  while (curr !== null && curr !== head) curr = curr.next;   // until the end, or back at the start5  return curr === head;                // back at the head: circular; fell off at null: not6}

Time O(n), space O(1). Starting at head.next matters: starting at the head itself, the loop would stop before taking a single step.

Comparing the approaches

If the loop could go back to any node, approach 2 would run forever on a list like 1 → 2 → 3 → 2. Then use Floyd's slow and fast pointers (Linked List Cycle) to find whether there's a loop at all, in O(1) space.

Edge cases to test

Variations