Floyd’s Cycle Finding Algorithm

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.

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:

• How does Floyd's Algorithm works ?
• Detect loop in Linked List
• Detect and Remove Loop in Linked List
• Find First node of a loop in a Linked List
• Find length of loop in a Linked List