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.
[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 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 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 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));
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 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 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 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));
Time Complexity: O(n), where n is the number of nodes in the Linked List.
Auxiliary Space: O(1)