Find length of loop/cycle in given Linked List

Last Updated : 26 Apr, 2025

Given the head of a linked list. The task is to find the length of the loop in the linked list. If the loop is not present return 0.

Examples:

Input: head: 1 → 2 → 3 → 4 → 5 → 2
Output: 4
Explanation: There exists a loop in the linked list and the length of the loop is 4.

Input: head: 25 → 14 → 19 → 33 → 10 → 21 → 39 → 90 → 58 → 45 → 33
Output: 7
Explanation: The loop is present in the below-linked list and the length of the loop is 7.

Input: head: 4 → 3 → 7 → 9 → 2
Output: 0
Explanation: There is no loop present in the Linked List.

Table of Content

[Naive Approach] Using Set – O(n) Time and O(n) Space:
[Expected Approach] Using Floyd’s Cycle Detection Algorithm – O(n) Time and O(1) Space

[Naive Approach] Using Set – O(n) Time and O(n) Space

The idea is to maintain a set to keep track of visited nodes so far. if the node is not present in set we will insert and move to another node , else we will maintain a counter from that node and will start traversing until we reach to it again by incrementing the counter variable every time.

C++

// C++ program to count number of nodes
// in loop in a linked list if loop is present
#include <bits/stdc++.h>
using namespace std;

class Node {
public:
    int data;
    Node* next;
	Node(int x) {
     	data = x;
      	next = nullptr;
    }
};

// This function detects and counts loop
// nodes in the list. If loop is not there
// then returns 0
int countNodesinLoop(Node* head) {
  
    unordered_set<Node*> visited;
    Node* current = head;
    int count = 0;

    while (current != nullptr) {
      
        // If the node is already visited, 
      	// it means there is a loop
        if (visited.find(current) != visited.end()) {
            struct Node* startOfLoop = current;
            do {
                count++;
                current = current->next;
            } while (current != startOfLoop);
            return count;
        }

        // Mark the current node as visited
        visited.insert(current);

        // Move to the next node
        current = current->next;
    }

    // Return 0 to indicate that
    //   there is no loop
    return 0;
}

int main() {
  	
  	Node* head = new Node(1);
    head->next = new Node(2);
    head->next->next = new Node(3);
    head->next->next->next = new Node(4);
    head->next->next->next->next = new Node(5);
  	
  	// Loop from 5 to 2
    head->next->next->next->next->next = head->next;

    cout << countNodesinLoop(head) << endl;

    return 0;
}

Java

// Java program to count number of nodes
// in loop in a linked list if loop is present
import java.util.*;

class Node {
    int data;
    Node next;
    Node(int x) {
        data = x;
        next = null;
    }
}

class GfG {

    // This function detects and counts loop
    // nodes in the list. If loop is not there
    // then returns 0
    static int countNodesinLoop(Node head) {

        HashSet<Node> visited = new HashSet<>();
        Node current = head;
        int count = 0;

        while (current != null) {

            // If the node is already visited, 
            // it means there is a loop
            if (visited.contains(current)) {
                Node startOfLoop = current;
                do {
                    count++;
                    current = current.next;
                } while (current != startOfLoop);
                return count;
            }

            // Mark the current node as visited
            visited.add(current);

            // Move to the next node
            current = current.next;
        }

        // Return 0 to indicate that
        //   there is no loop
        return 0;
    }

    public static void main(String[] args) {

        Node head = new Node(1);
        head.next = new Node(2);
        head.next.next = new Node(3);
        head.next.next.next = new Node(4);
        head.next.next.next.next = new Node(5);

        // Loop from 5 to 2
        head.next.next.next.next.next = head.next;

        System.out.println(countNodesinLoop(head));
    }
}

Python

# Python program to count number of nodes
# in loop in a linked list if loop is present

class Node:
    def __init__(self, x):
        self.data = x
        self.next = None

# This function detects and counts loop
# nodes in the list. If loop is not there
# then returns 0
def countNodesinLoop(head):

    visited = set()
    current = head
    count = 0

    while current is not None:

        # If the node is already visited, 
        # it means there is a loop
        if current in visited:
            startOfLoop = current
            while True:
                count += 1
                current = current.next
                if current == startOfLoop:
                    break
            return count

        # Mark the current node as visited
        visited.add(current)

        # Move to the next node
        current = current.next

    # Return 0 to indicate that
    #   there is no loop
    return 0

if __name__ == "__main__":

    head = Node(1)
    head.next = Node(2)
    head.next.next = Node(3)
    head.next.next.next = Node(4)
    head.next.next.next.next = Node(5)

    head.next.next.next.next.next = head.next

    print(countNodesinLoop(head))

// C# program to count number of nodes
// in loop in a linked list if loop is present
using System;
using System.Collections.Generic;

class Node {
    public int data;
    public Node next;
    public Node(int x) {
        data = x;
        next = null;
    }
}

class GfG {

    // This function detects and counts loop
    // nodes in the list. If loop is not there
    // then returns 0
    public static int countNodesinLoop(Node head) {

        HashSet<Node> visited = new HashSet<Node>();
        Node current = head;
        int count = 0;

        while (current != null) {

            // If the node is already visited, 
            // it means there is a loop
            if (visited.Contains(current)) {
                Node startOfLoop = current;
                do {
                    count++;
                    current = current.next;
                } while (current != startOfLoop);
                return count;
            }

            // Mark the current node as visited
            visited.Add(current);

            // Move to the next node
            current = current.next;
        }

        // Return 0 to indicate that
        //   there is no loop
        return 0;
    }

    public static void Main(string[] args) {

        Node head = new Node(1);
        head.next = new Node(2);
        head.next.next = new Node(3);
        head.next.next.next = new Node(4);
        head.next.next.next.next = new Node(5);
        head.next.next.next.next.next = head.next;

        Console.WriteLine(countNodesinLoop(head));
    }
}

JavaScript

// JavaScript program to count number of nodes
// in loop in a linked list if loop is present

class Node {
    constructor(x) {
        this.data = x;
        this.next = null;
    }
}

// This function detects and counts loop
// nodes in the list. If loop is not there
// then returns 0
function countNodesinLoop(head) {

    const visited = new Set();
    let current = head;
    let count = 0;

    while (current !== null) {

        // If the node is already visited, 
        // it means there is a loop
        if (visited.has(current)) {
            const startOfLoop = current;
            do {
                count++;
                current = current.next;
            } while (current !== startOfLoop);
            return count;
        }

        // Mark the current node as visited
        visited.add(current);

        // Move to the next node
        current = current.next;
    }

    // Return 0 to indicate that
    //   there is no loop
    return 0;
}

let head = new Node(1);
head.next = new Node(2);
head.next.next = new Node(3);
head.next.next.next = new Node(4);
head.next.next.next.next = new Node(5);

head.next.next.next.next.next = head.next;

console.log(countNodesinLoop(head));

Output

Time Complexity: O(n), where n is the number of nodes in the linked list.
Auxiliary Space: O(n)

[Expected Approach] Using Floyd’s Cycle Detection Algorithm – O(n) Time and O(1) Space

The idea is to use Floyd’s Cycle detection algorithm for detecting the common point in the loop.

If a common meeting point exists between the slow and fast pointers, it confirms the presence of a loop. Once the loop is detected, we start counting the number of nodes in the loop by initializing a counter and traversing the loop starting from the meeting point. We continue until we return to the same node, and the counter gives us the length of the loop.
else, If no meeting point is found, it means there is no loop, so we return 0.

C++

// C++ program to count number of nodes
// in loop in a linked list if loop is present
#include <bits/stdc++.h>
using namespace std;

class Node {
public:
    int data;
    Node* next;
  	Node(int x) {
     	data = x;
      	next = nullptr;
    }
};

// Returns count of nodes present in loop.
int countNodes(Node* node) {
    int res = 1;
    Node* curr = node;
    while (curr->next != node) {
        res++;
        curr = curr->next;
    }
    return res;
}

// This function detects and counts loop
//  nodes in the list. If loop is not there
//  then returns 0 
int countNodesinLoop(Node* head) {
    Node *slow = head, *fast = head;

    while (slow != nullptr && fast != nullptr 
           && fast->next != nullptr) {
               
        slow = slow->next;
        fast = fast->next->next;

        // If slow and fast meet at
        // some point then there is a loop
        if (slow == fast)
            return countNodes(slow);
    }

    // Return 0 to indicate that
    //   there is no loop
    return 0;
}

int main() {
  
    Node* head = new Node(1);
    head->next = new Node(2);
    head->next->next = new Node(3);
    head->next->next->next = new Node(4);
    head->next->next->next->next = new Node(5);

    // Loop from 5 to 2
    head->next->next->next->next->next = head->next;
    cout << countNodesinLoop(head) << endl;

    return 0;
}

Java

// Java program to count number of nodes
// in loop in a linked list if loop is present
class Node {
    int data;
    Node next;
    Node(int x) {
        data = x;
        next = null;
    }
}

class GfG {

    // Returns count of nodes present in loop.
    static int countNodes(Node node) {
        int res = 1;
        Node curr = node;
        while (curr.next != node) {
            res++;
            curr = curr.next;
        }
        return res;
    }

    // This function detects and counts loop
    //  nodes in the list. If loop is not there
    //  then returns 0 
    static int countNodesinLoop(Node head) {
        Node slow = head, fast = head;

        while (slow != null && fast != null 
               && fast.next != null) {

            slow = slow.next;
            fast = fast.next.next;

            // If slow and fast meet at
            // some point then there is a loop
            if (slow == fast)
                return countNodes(slow);
        }

        // Return 0 to indicate that
        //   there is no loop
        return 0;
    }

    public static void main(String[] args) {

        Node head = new Node(1);
        head.next = new Node(2);
        head.next.next = new Node(3);
        head.next.next.next = new Node(4);
        head.next.next.next.next = new Node(5);

        // Loop from 5 to 2
        head.next.next.next.next.next = head.next;
        System.out.println(countNodesinLoop(head));
    }
}

Python

# Python program to count number of nodes
# in loop in a linked list if loop is present

class Node:
    def __init__(self, x):
        self.data = x
        self.next = None

# Returns count of nodes present in loop.
def countNodes(node):
    res = 1
    curr = node
    while curr.next != node:
        res += 1
        curr = curr.next
    return res

# This function detects and counts loop
#  nodes in the list. If loop is not there
#  then returns 0 
def countNodesinLoop(head):
    slow = head
    fast = head

    while slow is not None and fast is not None \
          and fast.next is not None:

        slow = slow.next
        fast = fast.next.next

        # If slow and fast meet at
        # some point then there is a loop
        if slow == fast:
            return countNodes(slow)

    # Return 0 to indicate that
    #   there is no loop
    return 0

if __name__ == "__main__":

    head = Node(1)
    head.next = Node(2)
    head.next.next = Node(3)
    head.next.next.next = Node(4)
    head.next.next.next.next = Node(5)

    #loop from 5 to 2
    head.next.next.next.next.next = head.next
    print(countNodesinLoop(head))

// C# program to count number of nodes
// in loop in a linked list if loop is present
using System;

class Node {
    public int data;
    public Node next;
    public Node(int x) {
        data = x;
        next = null;
    }
}

class GfG {

    // Returns count of nodes present in loop.
    public static int countNodes(Node node) {
        int res = 1;
        Node curr = node;
        while (curr.next != node) {
            res++;
            curr = curr.next;
        }
        return res;
    }

    // This function detects and counts loop
    //  nodes in the list. If loop is not there
    //  then returns 0 
    public static int countNodesinLoop(Node head) {
        Node slow = head, fast = head;

        while (slow != null && fast != null 
               && fast.next != null) {

            slow = slow.next;
            fast = fast.next.next;

            // If slow and fast meet at
            // some point then there is a loop
            if (slow == fast)
                return countNodes(slow);
        }

        // Return 0 to indicate that
        // there is no loop
        return 0;
    }

    public static void Main(string[] args) {
        
        Node head = new Node(1);
        head.next = new Node(2);
        head.next.next = new Node(3);
        head.next.next.next = new Node(4);
        head.next.next.next.next = new Node(5);

        // Loop from 5 to 2
        head.next.next.next.next.next = head.next;
        Console.WriteLine(countNodesinLoop(head));
    }
}

JavaScript

// JavaScript program to count number of nodes
// in loop in a linked list if loop is present

class Node {
    constructor(x) {
        this.data = x;
        this.next = null;
    }
}

// Returns count of nodes present in loop.
function countNodes(node) {
    let res = 1;
    let curr = node;
    while (curr.next !== node) {
        res++;
        curr = curr.next;
    }
    return res;
}

// This function detects and counts loop
//  nodes in the list. If loop is not there
//  then returns 0 
function countNodesinLoop(head) {
    let slow = head, fast = head;

    while (slow !== null && fast !== null &&
           fast.next !== null) {

        slow = slow.next;
        fast = fast.next.next;

        // If slow and fast meet at
        // some point then there is a loop
        if (slow === fast)
            return countNodes(slow);
    }

    // Return 0 to indicate that
    //   there is no loop
    return 0;
}

let head = new Node(1);
head.next = new Node(2);
head.next.next = new Node(3);
head.next.next.next = new Node(4);
head.next.next.next.next = new Node(5);

// Loop from 5 to 2
head.next.next.next.next.next = head.next;
console.log(countNodesinLoop(head));

Output

Time Complexity: O(n), where n is the number of nodes in the Linked List.
Auxiliary Space: O(1)

Find an element in Bitonic array

Shubham Gupta

Improve

Article Tags :

Practice Tags :

Find length of loop/cycle in given Linked List

[Naive Approach] Using Set – O(n) Time and O(n) Space

[Expected Approach] Using Floyd’s Cycle Detection Algorithm – O(n) Time and O(1) Space

Similar Reads

Thank You!

What kind of Experience do you want to share?