Skip to content
geeksforgeeks
  • Courses
    • DSA to Development
    • Get IBM Certification
    • Newly Launched!
      • Master Django Framework
      • Become AWS Certified
    • For Working Professionals
      • Interview 101: DSA & System Design
      • Data Science Training Program
      • JAVA Backend Development (Live)
      • DevOps Engineering (LIVE)
      • Data Structures & Algorithms in Python
    • For Students
      • Placement Preparation Course
      • Data Science (Live)
      • Data Structure & Algorithm-Self Paced (C++/JAVA)
      • Master Competitive Programming (Live)
      • Full Stack Development with React & Node JS (Live)
    • Full Stack Development
    • Data Science Program
    • All Courses
  • Tutorials
    • Data Structures & Algorithms
    • ML & Data Science
    • Interview Corner
    • Programming Languages
    • Web Development
    • CS Subjects
    • DevOps And Linux
    • School Learning
  • Practice
    • Build your AI Agent
    • GfG 160
    • Problem of the Day
    • Practice Coding Problems
    • GfG SDE Sheet
  • Contests
    • Accenture Hackathon (Ending Soon!)
    • GfG Weekly [Rated Contest]
    • Job-A-Thon Hiring Challenge
    • All Contests and Events
  • DSA
  • Interview Problems on Linked List
  • Practice Linked List
  • MCQs on Linked List
  • Linked List Tutorial
  • Types of Linked List
  • Singly Linked List
  • Doubly Linked List
  • Circular Linked List
  • Circular Doubly Linked List
  • Linked List vs Array
  • Time & Space Complexity
  • Advantages & Disadvantages
Open In App
Next Article:
Detect and Remove Loop in Linked List
Next article icon

Find length of loop/cycle in given Linked List

Last Updated : 26 Apr, 2025
Comments
Improve
Suggest changes
Like Article
Like
Report
Try it on GfG Practice
redirect icon

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. 

Find-length-of-loop_cycle-in-given-Linked-List-2

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. 

Find-length-of-loop_cycle-in-given-Linked-List

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# 
// 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
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 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# 
// 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
4

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



Next Article
Detect and Remove Loop in Linked List

S

Shubham Gupta
Improve
Article Tags :
  • DSA
  • Linked List
  • Adobe
  • Qualcomm
Practice Tags :
  • Adobe
  • Qualcomm
  • Linked List

Similar Reads

  • Detect Loop or Cycle in Linked List
    Given a singly linked list, check if the linked list has a loop (cycle) or not. A loop means that the last node of the linked list is connected back to a node in the same list. Examples: Input: head: 1 -> 3 -> 4 -> 3Output: true Input: head: 1 -> 8 -> 3 -> 4 -> NULL Output: fals
    10 min read
  • Find first node of loop in a linked list
    Given the head of a linked list that may contain a loop. A loop means that the last node of the linked list is connected back to a node in the same list. The task is to find the Starting node of the loop in the linked list if there is no loop in the linked list return -1. Example: Input: Output: 3Ex
    14 min read
  • Insert a Node after a given Node in Linked List
    Given a linked list, the task is to insert a new node after a given node of the linked list. If the given node is not present in the linked list, print "Node not found". Examples: Input: LinkedList = 2 -> 3 -> 4 -> 5, newData = 1, key = 2Output: LinkedList = 2 -> 1 -> 3 -> 4 ->
    11 min read
  • Find pairs with given sum in doubly linked list
    Given a sorted doubly linked list of positive distinct elements, the task is to find pairs in a doubly-linked list whose sum is equal to the given value x in sorted order. Examples: Input: Output: (1, 6), (2,5)Explanation: We can see that there are two pairs (1, 6) and (2, 5) with sum 7. Input: Outp
    14 min read
  • Detect and Remove Loop in Linked List
    Given the head of a linked list that may contain a loop. A loop means that the last node of the linked list is connected back to a node in the same list. The task is to remove the loop from the linked list (if it exists). Example: Input: Output: 1 -> 3 -> 4 Explanation: The Loop is removed fro
    15 min read
  • Make all even values inside loop equal in given Linked list
    Given a linked list that contains integers, your task is to find the minimum cost for making all even numbers that are inside the cycle equal. You can perform the below-mentioned operations to achieve this : Increase a node's value by 1, this will cost 1 operation.Decrease a node's value by 1, this
    11 min read
  • Find Length of a Linked List (Iterative and Recursive)
    Given a Singly Linked List, the task is to find the Length of the Linked List. Examples: Input: LinkedList = 1->3->1->2->1Output: 5Explanation: The linked list has 5 nodes. Input: LinkedList = 2->4->1->9->5->3->6Output: 7 Explanation: The linked list has 7 nodes. Input:
    11 min read
  • Find the sum of last n nodes of the given Linked List
    Given a linked list and a number n. Find the sum of the last n nodes of the linked list.Constraints: 0 <= n <= number of nodes in the linked list. Examples: Input : 10->6->8->4->12, n = 2 Output : 16 Sum of last two nodes: 12 + 4 = 16 Input : 15->7->9->5->16->14, n =
    15+ min read
  • Insert a Node after a given node in Doubly Linked List
    Given a Doubly Linked List, the task is to insert a new node after a given node in the linked list. Examples: Input: Linked List = 1 <-> 2 <-> 4, newData = 3, key = 2Output: Linked List = 1 <-> 2 <-> 3 <-> 4Explanation: New node 3 is inserted after key, that is node 2.
    11 min read
  • Detect Cycle in a Linked List using Map
    Given a Linked List, check if the linked list has a loop or not.There are various methods shown here: Detect Cycle in Linked List Example Input: 20->4->54->6->NULL Output: No loop is detected. Explanation: While traversing the linked list, we reach the end of the linked list. Therefore,
    7 min read
geeksforgeeks-footer-logo
Corporate & Communications Address:
A-143, 7th Floor, Sovereign Corporate Tower, Sector- 136, Noida, Uttar Pradesh (201305)
Registered Address:
K 061, Tower K, Gulshan Vivante Apartment, Sector 137, Noida, Gautam Buddh Nagar, Uttar Pradesh, 201305
GFG App on Play Store GFG App on App Store
Advertise with us
  • Company
  • About Us
  • Legal
  • Privacy Policy
  • In Media
  • Contact Us
  • Advertise with us
  • GFG Corporate Solution
  • Placement Training Program
  • Languages
  • Python
  • Java
  • C++
  • PHP
  • GoLang
  • SQL
  • R Language
  • Android Tutorial
  • Tutorials Archive
  • DSA
  • Data Structures
  • Algorithms
  • DSA for Beginners
  • Basic DSA Problems
  • DSA Roadmap
  • Top 100 DSA Interview Problems
  • DSA Roadmap by Sandeep Jain
  • All Cheat Sheets
  • Data Science & ML
  • Data Science With Python
  • Data Science For Beginner
  • Machine Learning
  • ML Maths
  • Data Visualisation
  • Pandas
  • NumPy
  • NLP
  • Deep Learning
  • Web Technologies
  • HTML
  • CSS
  • JavaScript
  • TypeScript
  • ReactJS
  • NextJS
  • Bootstrap
  • Web Design
  • Python Tutorial
  • Python Programming Examples
  • Python Projects
  • Python Tkinter
  • Python Web Scraping
  • OpenCV Tutorial
  • Python Interview Question
  • Django
  • Computer Science
  • Operating Systems
  • Computer Network
  • Database Management System
  • Software Engineering
  • Digital Logic Design
  • Engineering Maths
  • Software Development
  • Software Testing
  • DevOps
  • Git
  • Linux
  • AWS
  • Docker
  • Kubernetes
  • Azure
  • GCP
  • DevOps Roadmap
  • System Design
  • High Level Design
  • Low Level Design
  • UML Diagrams
  • Interview Guide
  • Design Patterns
  • OOAD
  • System Design Bootcamp
  • Interview Questions
  • Inteview Preparation
  • Competitive Programming
  • Top DS or Algo for CP
  • Company-Wise Recruitment Process
  • Company-Wise Preparation
  • Aptitude Preparation
  • Puzzles
  • School Subjects
  • Mathematics
  • Physics
  • Chemistry
  • Biology
  • Social Science
  • English Grammar
  • Commerce
  • World GK
  • GeeksforGeeks Videos
  • DSA
  • Python
  • Java
  • C++
  • Web Development
  • Data Science
  • CS Subjects
@GeeksforGeeks, Sanchhaya Education Private Limited, All rights reserved
We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox
Improvement
Suggest Changes
Help us improve. Share your suggestions to enhance the article. Contribute your expertise and make a difference in the GeeksforGeeks portal.
geeksforgeeks-suggest-icon
Create Improvement
Enhance the article with your expertise. Contribute to the GeeksforGeeks community and help create better learning resources for all.
geeksforgeeks-improvement-icon
Suggest Changes
min 4 words, max Words Limit:1000

Thank You!

Your suggestions are valuable to us.

What kind of Experience do you want to share?

Interview Experiences
Admission Experiences
Career Journeys
Work Experiences
Campus Experiences
Competitive Exam Experiences