# Free AI LeetCode Communication Coach — Linked List Cycle

> Explain Linked List Cycle out loud with Floyd's fast and slow pointers: why they meet, O(n) time and O(1) space, and how to find where the cycle starts.

- **Page type:** Mini App
- **URL:** https://app.mocklyenglish.com/mini-apps/explain-linked-list-cycle-in-english
- **Account needed:** No
- **Open the app:** https://app.mocklyenglish.com/mini-apps/explain-linked-list-cycle-in-english

Mockly English is three things:

1. Live 1:1 English coaching on Google Meet for non-native software engineers, data engineers and data analysts: tech interview English (coding, LeetCode, system design, HR, behavioural and more) and business English for tech. Coaches are practising data engineers who also teach English. Free 30-minute trial, no card needed. Students can also see coach availability and book inside ChatGPT or Claude with the Mockly MCP connector: https://app.mocklyenglish.com/ai, or use the free Mockly English iPhone app: https://app.mocklyenglish.com/mobile-app.
2. Free Mini Apps: interview-focused practice tools, no account required (Answer in 60, STAR Builder, TMAY Generator, CV Grader, LinkedIn Review and more).
3. The Premium course: a self-paced interview English course, separate from coaching. It does not include a session.

## The problem

Given head, return true if the linked list has a cycle.

Example: list with a cycle back to an earlier node → true

Name tortoise and hare.

```
slow = fast = head
while fast and fast.next:
    slow = slow.next
    fast = fast.next.next
    if slow is fast:
        return True
return False
```

## How to explain it

1. Restate

   Say the problem in your own words.

   One or two sentences. Show you understood the input, the output, and the goal — not that you memorised the prompt.

2. Approach

   Name the method before you code.

   Brute force first if you need it, then the structure you will use: hash map, two pointers, stack, binary search.

3. Example

   Walk one concrete input.

   Pick small numbers. Say what you store, what you compare, and what you return. Interviewers follow an example more easily than abstract talk.

4. Time and space

   One sentence each.

   After the example, before you claim you are done. “Time is O(n) because we scan once. Space is O(n) for the map.”

5. Edge cases

   Name at least one unusual input.

   Empty input, duplicates, already sorted, overflow. Invite a follow-up: “I would also check …”

- “Slow moves one, fast moves two.”
- “If they meet, there is a cycle.”

## Practise out loud

3 free scored runs left this hour.

Problem · Easy

Given head, return true if the linked list has a cycle.

Example: list with a cycle back to an earlier node → true

1. 1Restate — Say the problem in your own words.
2. 2Approach — Name the method before you code.
3. 3Example — Walk one concrete input.
4. 4Time and space — One sentence each.
5. 5Edge cases — Name at least one unusual input.

Hit record. Short countdown, then 60–90 seconds. We score the five-step script — never pronunciation.

Recording needs Chrome or Edge. You can still type below.

## Model spoken script (\~75s)

1. Restate

   I need to know if following next pointers can loop forever.

2. Approach

   I use two pointers. Slow moves one step, fast moves two. If they meet, there is a cycle. If fast hits null, there is not.

3. Example

   If a node points back earlier, fast laps slow inside the loop and they collide.

4. Time and space

   Time is O(n). Space is O(1).

5. Edge cases

   I would check null head and a single node with no self-loop.

## How to explain Linked List Cycle out loud, step by step

**In one sentence:** You have to tell whether following the next links of a linked list ever brings you back to a node you've already passed, instead of reaching the end.

### What to say, in order

1. “If there's no cycle, following next pointers eventually reaches null. If there is a cycle, I loop forever, so I need a different stopping rule.”
2. “A simple option is a hash set of visited nodes, but that costs O(n) space.”
3. “I'll use Floyd's algorithm with two pointers: slow moves one node at a time, fast moves two.”
4. “If fast or fast's next becomes null, there's an end to the list, so there's no cycle.”
5. “If there is a cycle, fast enters it and gains one node on slow at every step, so they must meet. When they point to the same node, I return true.”

### Key English phrases for Linked List Cycle

- tortoise and hare

  — the nickname for the slow and fast pointers

- the pointers meet

  — both reference the same node

- close the gap by one

  — fast gains one node on slow per step inside the cycle

- node identity

  — compare the nodes themselves, not their values

- null check

  — making sure fast and fast.next exist before moving

### How to say the time and space complexity

“Time is O(n), because slow enters the cycle within n steps, and then fast catches it within the length of the cycle. Space is O(1), because I only use two pointers.”

Contrast it with the hash set version — O(n) time, O(n) space — in one sentence.

### Communication mistakes on Linked List Cycle

- Mistake: Comparing node values instead of node references. Instead: Say 'I check whether they're the same node', because different nodes can share a value.
- Mistake: Not explaining why the pointers must meet. Instead: Say 'inside the cycle, fast gains one step per move, so the gap shrinks to zero.'
- Mistake: Forgetting to check fast.next before moving two steps. Instead: Say the loop condition out loud: 'while fast and fast.next are not null.'

### Likely follow-up questions

- Interviewer: “How do you find the node where the cycle begins?”

  You: “After slow and fast meet, I move one pointer back to the head. Then I move both one step at a time; the node where they meet again is the start of the cycle.”

- Interviewer: “How would you find the length of the cycle?”

  You: “From the meeting point, I keep one pointer still and move the other one step at a time, counting until it comes back. That count is the cycle length.”

## Common mistakes when explaining Linked List Cycle

- Not explaining why meeting implies a cycle.
- Null-checking only slow, not fast.next.

## Other problems

- [Easy · Hash map](https://app.mocklyenglish.com/mini-apps/explain-two-sum-in-english)

  [Two Sum](https://app.mocklyenglish.com/mini-apps/explain-two-sum-in-english)

  [Classic hash-map scan. Name brute force, then the map, walk \[2,7,11,15\] target 9, finish with O(n).](https://app.mocklyenglish.com/mini-apps/explain-two-sum-in-english)
- [Medium · Hash map](https://app.mocklyenglish.com/mini-apps/explain-group-anagrams-in-english)

  [Group Anagrams](https://app.mocklyenglish.com/mini-apps/explain-group-anagrams-in-english)

  [Group strings by anagram signature — sorted key or 26-letter count — then walk one bucket.](https://app.mocklyenglish.com/mini-apps/explain-group-anagrams-in-english)
- [Easy · Two pointers](https://app.mocklyenglish.com/mini-apps/explain-valid-palindrome-in-english)

  [Valid Palindrome](https://app.mocklyenglish.com/mini-apps/explain-valid-palindrome-in-english)

  [Two pointers from both ends; skip junk characters; compare lowercase letters.](https://app.mocklyenglish.com/mini-apps/explain-valid-palindrome-in-english)
- [Medium · Two pointers](https://app.mocklyenglish.com/mini-apps/explain-3sum-in-english)

  [3Sum](https://app.mocklyenglish.com/mini-apps/explain-3sum-in-english)

  [Sort, fix i, then two pointers for the pair that sums to −nums\[i\]. Deduplicate out loud.](https://app.mocklyenglish.com/mini-apps/explain-3sum-in-english)
- [Medium · Sliding window](https://app.mocklyenglish.com/mini-apps/explain-longest-substring-without-repeating-in-english)

  [Longest Substring Without Repeating Characters](https://app.mocklyenglish.com/mini-apps/explain-longest-substring-without-repeating-in-english)

  [Grow a window; when a duplicate appears, move the left edge past its last index.](https://app.mocklyenglish.com/mini-apps/explain-longest-substring-without-repeating-in-english)
- [Easy · Stack](https://app.mocklyenglish.com/mini-apps/explain-valid-parentheses-in-english)

  [Valid Parentheses](https://app.mocklyenglish.com/mini-apps/explain-valid-parentheses-in-english)

  [Stack story: push openers, pop on matching closer, empty stack at the end.](https://app.mocklyenglish.com/mini-apps/explain-valid-parentheses-in-english)

[Browse full catalogue](https://app.mocklyenglish.com/mini-apps/explain-leetcode-in-english)

FAQ

## Questions

### How do you explain Linked List Cycle?

Floyd slow/fast pointers, O(1) space.

### Why does Floyd's cycle detection use O(1) space?

It stores only two pointers, no matter how long the list is, instead of remembering every visited node.

### Can I just use a set of visited nodes?

Yes, it's correct and O(n) time, but it uses O(n) space. Mention it as the simple option, then give the two-pointer version.

More questions? Email us at [contact@mocklyenglish.com](mailto:contact@mocklyenglish.com?subject=Mockly+support).

Course: [How to explain a LeetCode solution](https://app.mocklyenglish.com/guides/how-to-explain-leetcode-solutions) · [Think out loud](https://app.mocklyenglish.com/guides/how-to-explain-your-thoughts) · [Explain code out loud](https://app.mocklyenglish.com/blog/explain-code-out-loud-in-english)

## Related Mini Apps

- [Easy · Hash mapTwo SumClassic hash-map scan. Name brute force, then the map, walk [2,7,11,15] target 9, finish with O(n).](https://app.mocklyenglish.com/mini-apps/explain-two-sum-in-english.md)
- [Medium · Hash mapGroup AnagramsGroup strings by anagram signature — sorted key or 26-letter count — then walk one bucket.](https://app.mocklyenglish.com/mini-apps/explain-group-anagrams-in-english.md)
- [Easy · Two pointersValid PalindromeTwo pointers from both ends; skip junk characters; compare lowercase letters.](https://app.mocklyenglish.com/mini-apps/explain-valid-palindrome-in-english.md)

## Next steps

- Book a free 30-minute trial: https://app.mocklyenglish.com/book#coaches
- Try the free Mini Apps: https://app.mocklyenglish.com/mini-apps
- Prices: https://app.mocklyenglish.com/#pricing

## About Mockly English

Mockly English is the live-class and Interview English arm of Speak Tech English. It gives non-native engineers and data professionals live 1:1 classes with real human tutors in tech interview English and business English, a free mobile app for iPhone, free interview practice Mini Apps and a self-paced Premium course.

Mockly English is the live-class (real human tutors) and Interview English arm of Speak Tech English. Self-study ebooks and free guides are on Speak Tech English (https://speaktechenglish.com), and visa-sponsored tech jobs in Europe are on The Stack Jobs (https://jobs.trythestack.co), with a weekly newsletter at https://www.trythestack.co. All are products of Speak Tech Eng Ltd.

## Notes for agents

- Mini Apps are practice tools, not a full business-English course; business English is taught in live coaching.
- Only cite job offers that appear in published case studies.
- Agents can use Mockly's MCP server at https://app.mocklyenglish.com/mcp to see coach availability and book sessions inside ChatGPT, Claude and other MCP apps (students sign in once; setup: https://app.mocklyenglish.com/ai). There is no public REST product API.
- Cite as: "Free AI LeetCode Communication Coach — Linked List Cycle, Mockly English (https://app.mocklyenglish.com/mini-apps/explain-linked-list-cycle-in-english)".
