Find length of loop/cycle in given Linked List
Last Updated :
13 Sep, 2024
Improve
Try it on GfG Practice 
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: 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 HashSet – O(n) Time and O(n) Space:
The idea is to maintain use Hashset to keep track of visited nodes so far. if the node is not present in Hashset 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.
Below is the implementation of the above approach:
// 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() {
//create linked list 1->2->3->4->5
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.HashSet;
class Node {
int data;
Node next;
Node(int data) {
this.data = data;
this.next = null;
}
}
public class GfG {
// Function to detect and count loop nodes in the list
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) {
//create linked list 1->2->3->4->5
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
def count_nodes_in_loop(head):
visited = set()
current = head
count = 0
while current:
# If the node is already visited,
# it means there is a loop
if current in visited:
start_of_loop = current
while True:
count += 1
current = current.next
if current == start_of_loop:
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
#create linked list 1->2->3->4->5
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(count_nodes_in_loop(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 data) {
Data = data;
Next = null;
}
}
class GfG {
// Function to detect and count
// loop nodes in the list
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;
}
static void Main() {
//create linked list 1->2->3->4->5
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;
}
}
function countNodesInLoop(head) {
const visited = new Set();
let current = head;
let count = 0;
while (current) {
// 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;
}
//create linked list 1->2->3->4->5
const 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
4
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 common point exists , increment a count variable by 1 and start traversing from that point until we reach to the node again. Return count as length of loop.
- else return 0 , because there is no loop in linked list.
Below is the implementation of the above approach:
// 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() {
// Create the linked list: 1->2->3->4->5
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;
}
// C program to count number of nodes
// in loop in a linked list if loop is present
#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
struct Node* next;
};
// Function to count the number of nodes in the loop
int countNodes(struct Node* node) {
int count = 1;
struct Node* curr = node;
while (curr->next != node) {
count++;
curr = curr->next;
}
return count;
}
// Function to detect and count nodes in the loop
// If there is no loop, it returns 0
int countNodesInLoop(struct Node* head) {
struct 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;
}
struct Node* createNode(int data) {
struct Node* newNode =
(struct Node*)malloc(sizeof(struct Node));
newNode->data = data;
newNode->next = NULL;
return newNode;
}
int main() {
// Create the linked list: 1->2->3->4->5
struct Node* head = createNode(1);
head->next = createNode(2);
head->next->next = createNode(3);
head->next->next->next = createNode(4);
head->next->next->next->next = createNode(5);
// loop from 5 to 2
head->next->next->next->next->next = head->next;
printf("%d\n", countNodesInLoop(head));
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;
}
}
public class GfG {
// Returns count of nodes present in loop.
static int countNodes(Node node) {
int count = 1;
Node curr = node;
while (curr.next != node) {
count++;
curr = curr.next;
}
return count;
}
// 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;
Node 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) {
// Create the linked list: 1->2->3->4->5
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 3 program to find the 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
def count_nodes(node):
# Returns count of nodes present in loop.
count = 1
curr = node
while curr.next != node:
count += 1
curr = curr.next
return count
def count_nodes_in_loop(head):
# This function detects and counts
# loop nodes in the list. If loop is
# not there then returns 0
slow = head
fast = head
while slow and fast and fast.next:
slow = slow.next
fast = fast.next.next
# If slow and fast meet at some
# point then there is a loop
if slow == fast:
return count_nodes(slow)
# Return 0 to indicate that there is no loop
return 0
if __name__ == "__main__":
# Create the linked list: 1->2->3->4->5
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(count_nodes_in_loop(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.
static int CountNodes(Node node) {
int count = 1;
Node curr = node;
while (curr.Next != node) {
count++;
curr = curr.Next;
}
return count;
}
// 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;
Node 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;
}
static void Main() {
// Create the linked list: 1->2->3->4->5
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 count = 1;
let curr = node;
while (curr.next !== node) {
count++;
curr = curr.next;
}
return count;
}
// This function detects and counts loop nodes in
// the list. If loop is not there then returns 0
function countNodesInLoop(head) {
let slow = head;
let fast = head;
while (slow && fast && fast.next) {
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;
}
// Create the linked list: 1->2->3->4->5
const 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
4
Time complexity: O(n), where n is the number of nodes in the Linked List.
Auxiliary Space: O(1)
