Floyd’s Cycle Finding Algorithm (original) (raw)

Last Updated : 23 Jul, 2025

**Floyd's cycle finding algorithm or **Hare-Tortoise algorithm is a pointer algorithm that uses only **two pointers, moving through the sequence at different speeds. This algorithm is used to find a loop in a **linked list. It uses two pointers one moving **twice as **fast as the other one. The **faster one is called the fast pointer and the other one is called the slow pointer.

While traversing the linked list one of these things will occur-

The **Fast pointer may reach the end (NULL) which shows that there is no loop in the linked list.
The **Fast pointer again catches the slow pointer at some time therefore a loop exists in the linked list.

Table of Content

Floyd’s Cycle Finding Algorithm
How does Floyd's Algorithm works?
Find the node where cycle starts
Advantages

**Floyd’s Cycle Finding Algorithm:

The idea is to start with the two pointers slow and **fast, both starting at the **head of the linked list.

While traversing the List:
- **slow pointer will move one step at a time.
- **fast pointer moves two steps at a time.
- If there's a **cycle, the fast pointer will eventually catch up with the slow pointer within the cycle because it's moving faster.
- If there's no cycle, the fast pointer will reach the end of the list (i.e., it will become **NULL).
When the slow and fast pointers meet, a **cycle or **loop exists.

For more details about the working of this algorithm, Please refer to this article Detect loop or cycle in a linked list.

How does Floyd's Algorithm works?

The algorithm is to start two pointers, **slow and **fast from head of linked list. We move slow one node at a time and fast two nodes at a time. If there is a loop, then they will definitely meet.

This approach works because of the following facts :

When **slow pointer enters the loop, the **fast pointer must be inside the loop.

if we consider movements of **slow and **fast pointers, we can notice that **distance between them (from slow to fast) increase by **one after every iteration.

After each iteration where the **slow pointer moves one step forward and the **fast pointer moves two steps forward, the distance between the two pointers increases. Initially, if the **slow pointer is at a distance k from a certain point in the cycle, then after one iteration, the distance between the **slow and **fast pointers becomes k+1. After two iterations, this distance becomes k+2 and so on. As they continue to move within the cycle, this distance will eventually equal the cycle length **n. At this point, since the distance wraps around the cycle and both pointers are moving within the same cycle, they will meet.

For more details about the working & proof of this algorithm, Please refer to this article, How does Floyd's Algorithm works.

Find the Starting Node of a Cycle in a Linked List

To find the starting node of a cycle in a linked list, follow the steps below:

Using above algorithm we can find the **meeting point (if cycle exists) where the slow and fast pointers **intersect inside the cycle.

After detecting the cycle, reset one pointer ****(slow)** to the **head of the list. Keep the other pointer (fast) at the meeting point.

Move both pointers **one step at a time. The node where they meet again is the **start of the cycle.

For more details about the working of this algorithm, Please refer to this article, Find the Starting Node of a Cycle in a Linked List.

Advantages :

It avoids the need for extra space (like a hash table) to keep track of **visited nodes, making it very memory efficient.
This algorithm can also be adapted to **find the middle element of a linked list****.**

**Related articles: