JavaScript Program for Finding the Length of Loop in Linked List

In this program, we will be given a linked list that may consist of a loop and we have to find if the loop exists then what will be the size of the loop. Let’s a very famous approach to finding the length of a loop with the help of a code and discuss its time and space complexity.

Introduction to Problem

In this problem, as we have seen above we are given a linked list that may or may not contain a loop in it and we have to find the length of the loop if it exits otherwise we have to return zero as there is no loop present. We will use the Floyd loop method to find the loop and then check its size. For example, if we are given a linked list as −

List: 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8

And there is a loop from the node containing 8 to the node containing 4, which means 8 is connected to 4 making the loop of length 5 and we have to detect it.


In this problem, we will use the Floyd loop method to detect the loop and then we will use the concept of length finding to find the length of the loop. Let's first see the basic steps of the problem then we will move to Floyd’s method and length method.

  • First, we will create the class to provide the basic structure of the nodes of the linked list and define constructors in it to initialize the node values.

  • Then we created a function to push the elements in the given linked list.

  • We have created a linked list using the above method and then we have linked the last node to another node to make a cycle in it.

Floyd’s Algorithm

In this algorithm, we traverse over the linked list and once we have entered the linked list then we cannot go out from any node. This means if we have two pointers in that linked list loop part and one pointer is moving forward with one node at a time and another is at the pace of two nodes at a time, they will meet at a certain point.

  • After implementing the algorithm, we will call that function and check if the loop is present or not

  • If the loop is present than we will call to the anther function to find the length of the loop.

  • Another wise we will return and print no loop is present.


In the below example, we define a linked list and add 8 nodes to it. We make loop in a linked list by connecting node 8 to node 4. So it makes a loop of five nodes.

// class to provide the structure to the linked list node
class Node{
   constructor(data) {
      this.value = data = null;
// function to add values in a linked list
function push(data, head) {
   var new_node = new Node(data);
   if(head == null) {
      head = new_node;
      return head;
   var temp = head
   while( != null) {
      temp =;
   } = new_node;
   return head;
// function to find the length in the loop 
function length(loop_node) {
   var count = 1;
   var temp = loop_node;
   while( != loop_node) {
      temp =;
   console.log("The length of the loop in the given linked list is: " + count);
// function to find the cycle in the given list 
// if the cycle is found then call the length function 
function find_node(head) {
   var slow_ptr = head;
   var fast_ptr = head;
   while(slow_ptr != null && fast_ptr != null && != null) {
      slow_ptr =;
      fast_ptr =;
      if(slow_ptr == fast_ptr) {
   console.log("There is no loop present in the given linked list");

var head = null;

head = push(1,head)
head = push(2,head)
head = push(3,head)
head = push(4,head)
head = push(5,head)
head = push(6,head)
head = push(7,head)
head = push(8,head)

// making loop in a linked list by connecting 8 to four 
var temp = head;
while(temp.value != 4){
   temp =;
var temp2 = head;
while( != null){
   temp2 =
} = temp
// finding the length of the loop 

Time and Space Complexity

In the above code, we have traversed over the complete linked list only once and for the loop part maximum of three times which makes the time complexity linear. So the time complexity of the above code is linear that is O(N) where N is the size of the linked list.

As we are not using any extra space makes the time complexity of the program O(1).


In this tutorial, we have learned how to find the length of the loop present in the linked list by implementing the concepts in the JavaScript language. We have used Floyd’s loop-finding algorithm to find the loop in the given linked list and then we have just used the while loop to traverse over the loop and find its length. The time complexity of the above code is O(N) and the space complexity is O(1).

Updated on: 24-Mar-2023


Kickstart Your Career

Get certified by completing the course

Get Started