Open In App

Detect and Remove Loop in Linked List

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

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 from the above example.

Input:

Output: 1 -> 8 -> 3 -> 4
Explanation: There is no Loop in the above example.

Table of Content

[Naive Approach] Detect and Remove Loop using Hashing - O(n) Time and O(n) Space

The idea is to start traversing the Linked List from head node and while traversing insert each node into the HashSet. Also, maintain a prev pointer which points to the previous node of the current node. If there is a loop present in the Linked List, there will be a node which will be already present in the hash set.

  • If there is a node which is already present in the HashSet, then update the next pointer of prev to NULL to remove the loop from the linked list.
  • else, if there is no node which is already present in the HashSet , then there is no loop in the linked list.
C++ 
//Driver Code Starts
// C++ code to detect and remove loop in
// linked list using hashing

#include <bits/stdc++.h>
using namespace std;

struct Node {
    int data;
    Node *next;

    Node(int x) {
        data = x;
        next = nullptr;
    }
};

void printList(Node *curr) {
    while (curr != nullptr) {
        cout << curr->data << " ";
        curr = curr->next;
    }
    cout << endl;
}
//Driver Code Ends


// Function to detect and remove loop in
// a linked list
void removeLoop(Node *head) {

    // hash set to hash addresses of
    // the linked list nodes
    unordered_set<Node *> st;

    // pointer to prev node
    Node *prev = nullptr;
    while (head != nullptr) {

        // if node not present in the map,
        // insert it in the map
        if (st.find(head) == st.end()) {
            st.insert(head);
            prev = head;
            head = head->next;
        }
      
        // if present, it is a cycle, make
        // last node's next pointer NULL
        else {
            prev->next = nullptr;
            break;
        }
    }
}


//Driver Code Starts
int main() {
  
	// Create a hard-coded linked list: 
	// 1 -> 3 -> 4
    Node *head = new Node(1);
    head->next = new Node(3);
    head->next->next = new Node(4);

	// Create a loop
    head->next->next->next = head->next;

    removeLoop(head);
    printList(head);

    return 0;
}
//Driver Code Ends
Java 
//Driver Code Starts
// Java code to detect and remove loop in linked
// list using hashing

import java.util.HashSet;

class Node {
    int data;
    Node next;

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

class GfG {

    static void printList(Node curr) {
        while (curr != null) {
            System.out.print(curr.data + " ");
            curr = curr.next;
        }
        System.out.println();
    }
//Driver Code Ends


    // Function to detect and remove loop in a linked list
    static void removeLoop(Node head) {

        // hash set to hash addresses of
        // the linked list nodes
        HashSet<Node> st = new HashSet<>();

        // pointer to prev node
        Node prev = null;
        while (head != null) {

            // if node not present in the map,
            // insert it in the map
            if (!st.contains(head)) {
                st.add(head);
                prev = head;
                head = head.next;
            }

            // if present, it is a cycle, make
            // last node's next pointer NULL
            else {
                prev.next = null;
                break;
            }
        }
    }


//Driver Code Starts
    public static void main(String[] args) {

        // Create a hard-coded linked list:
        // 1 -> 3 -> 4
        Node head = new Node(1);
        head.next = new Node(3);
        head.next.next = new Node(4);

        // Create a loop
        head.next.next.next = head.next;

        removeLoop(head);
        printList(head);
    }
}
//Driver Code Ends
Python 
#Driver Code Starts
# Python code to detect and remove loop in linked 
# list using hashing

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

def printList(curr):
  
    # Function to print the linked list
    while curr:
        print(curr.data, end=' ')
        curr = curr.next
    print()
#Driver Code Ends


def removeLoop(head):
  
    # Function to detect and remove loop from linked list
    nodeSet = set()
    prev = None
    while head:
      
        # If node is already in the set, remove the loop
        if head in nodeSet:
            prev.next = None
            return

        # Add node to the set and move forward
        nodeSet.add(head)
        prev = head
        head = head.next


#Driver Code Starts
if __name__ == "__main__":
	
    # Create a hard-coded linked list: 
	# 1 -> 3 -> 4
    head = Node(1)
    head.next = Node(3)
    head.next.next = Node(4)
    
    # Create a loop
    head.next.next.next = head.next

    removeLoop(head)
    printList(head)
#Driver Code Ends
C# 
//Driver Code Starts
// C# code to detect and remove loop in a 
// linked list using hashing

using System;
using System.Collections.Generic;

class Node {
    public int data;
    public Node next;

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

class GfG {
    static void PrintList(Node curr) {
        while (curr != null) {
            Console.Write(curr.data + " ");
            curr = curr.next;
        }
    }
//Driver Code Ends


    // Function to detect and remove loop from linked list
    static void removeLoop(Node head) {
        HashSet<Node> st = new HashSet<Node>();
        Node prev = null;
        while (head != null) {
            
          	// If we have already seen this node in 
          	// hash set, it means there is a cycle.
            // Set the next of the previous pointer 
          	// to null to remove the cycle.
            if (st.Contains(head)) {
                prev.next = null;
                return;
            }
          
            // If we are seeing the node for the first time,
          	// insert it in hash set.
            else {
                st.Add(head);
                prev = head;
                head = head.next;
            }
        }
    }


//Driver Code Starts
    static void Main(string[] args) {
    	
    	// Create a hard-coded linked list: 
		// 1 -> 3 -> 4
        Node head = new Node(1);
        head.next = new Node(3);
        head.next.next = new Node(4);

        // Create a loop
    	head.next.next.next = head.next;

        removeLoop(head);
        PrintList(head);
    }
}

//Driver Code Ends
JavaScript 
//Driver Code Starts
// JavaScript code to detect and remove loop in a
// linked list using hashing

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

function printList(curr) {
    while (curr != null) {
        console.log(curr.data + " ");
        curr = curr.next;
    }
}
//Driver Code Ends


// Function to detect and remove loop from linked list
function removeLoop(head) {
    let st = new Set();
    let prev = null;
    while (head != null) {
    
        // If node is already in the set, remove the loop
        if (st.has(head)) {
            prev.next = null;
            return;
        }
        
        // Add node to the set and move forward
        st.add(head);
        prev = head;
        head = head.next;
    }
}


//Driver Code Starts
// Create a hard-coded linked list: 
// 1 -> 3 -> 4
head = new Node(1);
head.next = new Node(3);
head.next.next = new Node(4);

// Create a loop
head.next.next.next = head.next;

removeLoop(head);
printList(head);

//Driver Code Ends

Output
1 3 4

Time Complexity: O(n), Where n is the number of nodes in the linked list.
Auxiliary Space: O(n), Where n is the number of nodes in the linked list(due to hashing).

[Efficient Approach] Using Floyd's Cycle Detection Algorithm - O(n) Time and O(1) Space

This approach can be divided into two parts:

1. Detect Loop in Linked List using Floyd's Cycle Detection Algorithm:

  • Use two pointers, slow and fast and initialize them with the head of the linked list.
  • Move the fast pointer forward by two nodes and move the slow pointer forward by one node.
  • If the slow and fast pointer points to the same node, loop is found.
  • Else if the fast pointer reaches NULL, then no loop is found.
  • Else repeat the above steps till we reach the end of the linked list or a loop is found.

2. Remove Loop in Linked List (if any):

The idea is similar to finding the starting node of Loop in a Linked List. For this, we will point the slow pointer to head node and fast pointer will remain at its position. Both slow and fast pointers move one step ahead until fast->next is not equals to slow->next. When slow->next equals to fast->next we can easily point fast->next to NULL to remove the loop.


C++ 
//Driver Code Starts
// C++ program Using Floyd's Cycle Detection Algorithm

#include <bits/stdc++.h>
using namespace std;

struct Node {
    int data;
    Node *next;

    Node(int x) {
        data = x;
        next = nullptr;
    }
};

void printList(Node *curr) {
    while (curr != nullptr) {
        cout << curr->data << " ";
        curr = curr->next;
    }
    cout << endl;
}
//Driver Code Ends


// Function to detect and remove loop in a linked list that
// may contain loop
void removeLoop(Node *head) {
  
    // If list is empty or has only one node without loop
    if (head == nullptr || head->next ==nullptr)
        return;

    Node *slow = head, *fast = head;

    // Move slow and fast 1 and 2 steps ahead respectively.
    slow = slow->next;
    fast = fast->next->next;

    // Search for loop using slow and fast pointers
    while (fast && fast->next) {
        if (slow == fast)
            break;
        slow = slow->next;
        fast = fast->next->next;
    }

    // If loop exists
    if (slow == fast) {
        slow = head;

        // this check is needed when slow and fast both meet
        // at the head of the LL
        if (slow == fast)
            while (fast->next != slow)
                fast = fast->next;
        else {
            while (slow->next != fast->next) {
                slow = slow->next;
                fast = fast->next;
            }
        }

        // since fast->next is the looping point 
        fast->next = nullptr;
    }
}


//Driver Code Starts
int main() {
  
	// Create a hard-coded linked list:
	// 1 -> 3 -> 4
    Node *head = new Node(1);
    head->next = new Node(3);
    head->next->next = new Node(4);
  
	// Create a loop
    head->next->next->next = head->next;

    removeLoop(head);
    printList(head);

    return 0;
}
//Driver Code Ends
C 
//Driver Code Starts
// C program Using Floyd's Cycle Detection Algorithm

#include <stdio.h>
#include <stdlib.h>

struct Node {
    int key;
    struct Node *next;
};


void printList(struct Node *curr) {
    while (curr != NULL) {
        printf("%d ", curr->key);
        curr = curr->next;
    }
    printf("
");
}
//Driver Code Ends


// Function to detect and remove loop in a linked list that
// may contain loop
void removeLoop(struct Node *head) {
  
    // If list is empty or has only one node without loop
    if (head == NULL || head->next == NULL)
        return;

    struct Node *slow = head, *fast = head;

    // Move slow and fast 1 and 2 steps ahead respectively.
    slow = slow->next;
    fast = fast->next->next;

    // Search for loop using slow and fast pointers
    while (fast && fast->next) {
        if (slow == fast)
            break;
        slow = slow->next;
        fast = fast->next->next;
    }

    // If loop exists
    if (slow == fast) {
        slow = head;

        // this check is needed when slow and fast both meet
        // at the head of the LL
        if (slow == fast)
            while (fast->next != slow)
                fast = fast->next;
        else {
            while (slow->next != fast->next) {
                slow = slow->next;
                fast = fast->next;
            }
        }

        // since fast->next is the looping point
        // remove loop
        fast->next = NULL;
    }
}


//Driver Code Starts
struct Node *createNode(int key) {
   struct Node *curr = 
     	(struct Node *)malloc(sizeof(struct Node));
    curr->key = key;
    curr->next = NULL;
    return curr;
}

int main() {
	
	// Create a hard-coded linked list:
	// 1 -> 3 -> 4
    struct Node *head = createNode(1);
    head->next = createNode(3);
    head->next->next = createNode(4);
  
	// Create a loop
    head->next->next->next = head->next;

    removeLoop(head);
    printList(head);

    return 0;
}
//Driver Code Ends
Java 
//Driver Code Starts
// Java program Using Floyd's Cycle Detection Algorithm 
class Node {

	int data;
    Node next;

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

class GfG {
//Driver Code Ends

  
    // Function that detects loop in the list
    static void removeLoop(Node head) {

        // If list is empty or has only one node
        // without loop
        if (head == null || head.next == null)
            return;

        Node slow = head, fast = head;

        // Move slow and fast 1 and 2 steps
        // ahead respectively.
        slow = slow.next;
        fast = fast.next.next;

        // Search for loop using slow and fast pointers
        while (fast != null && fast.next != null) {
            if (slow == fast)
                break;

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

        // If loop exists 
        if (slow == fast) {
            slow = head;
            if (slow != fast) {
                while (slow.next != fast.next) {
                    slow = slow.next;
                    fast = fast.next;
                }
              
                // since fast->next is the looping point 
                // remove loop 
              	fast.next = null; 
            }
              // This case is added if fast and slow
          	 // pointer meet at first position. 
            else {
                while(fast.next != slow) {
                    fast = fast.next;
                }
                fast.next = null;
            }
        }
    }


//Driver Code Starts
    static void printList(Node curr) {
        while (curr != null) {
            System.out.print(curr.data + " ");
            curr = curr.next;
        }
    }

    public static void main(String[] args) {
		
		// Create a hard-coded linked list:
		// 1 -> 3 -> 4
        Node head = new Node(1);
        head.next = new Node(3);
        head.next.next = new Node(4);

        // Create a loop
		head.next.next.next = head.next;
        
		removeLoop(head);
        printList(head);
    }
}

//Driver Code Ends
Python 
#Driver Code Starts
# Python program Using Floyd's Cycle Detection Algorithm

class Node:
    def __init__(self, x):
        self.data = x
        self.next = None
#Driver Code Ends


# Function to remove the loop from the linked list
def removeLoop(head):
  
    # If the list is empty or has only one node 
    # without a loop
    if head is None or head.next is None:
        return

    slow = head
    fast = head

    # Move slow and fast pointers; slow moves 1 step, 
    # fast moves 2 steps
    while slow and fast and fast.next:
        slow = slow.next
        fast = fast.next.next

        # If slow and fast meet, a loop is detected
        if slow == fast:
            slow = head

            # Move slow and fast pointers to find the node 
            # where the loop starts
            while slow != fast:
                slow = slow.next
                fast = fast.next

            # Traverse the loop to find the node where the 
            # loop ends and remove it
            while fast.next != slow:
                fast = fast.next
            fast.next = None  


#Driver Code Starts
def printList(curr):
    while curr:
        print(curr.data, end=' ')
        curr = curr.next
    print()


if __name__ == "__main__":
  
    # Create a linked list:
    # 1 -> 3 -> 4
    head = Node(1)
    head.next = Node(3)
    head.next.next = Node(4)

    # Creating a loop 
    head.next.next.next = head.next

    # Remove the loop from the linked list
    removeLoop(head)

    printList(head)

#Driver Code Ends
C# 
//Driver Code Starts
// C# program Using Floyd's Cycle Detection Algorithm 

class Node {
    public int data;
    public Node next;

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

class GfG {
//Driver Code Ends

  
    // Function that detects loop in the list
    static void removeLoop(Node head) {
      
        // If list is empty or has only one node
        // without loop
        if (head == null || head.next == null)
            return;

        Node slow = head, fast = head;

        // Move slow and fast 1 and 2 steps
        // ahead respectively.
        slow = slow.next;
        fast = fast.next.next;

        // Search for loop using slow and fast pointers
        while (fast != null && fast.next != null) {
            if (slow == fast)
                break;

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

        // If loop exists 
        if (slow == fast) {
            slow = head;
            if (slow != fast) {
                while (slow.next != fast.next) {
                    slow = slow.next;
                    fast = fast.next;
                }

                // since fast->next is the looping point 
                // remove loop 
                fast.next = null;
            }
          
            // This case is added if fast and slow pointer
          	// meet at first position. 
            else {
                while (fast.next != slow) {
                    fast = fast.next;
                }
                fast.next = null;
            }
        }
    }


//Driver Code Starts
    static void printList(Node curr) {
        while (curr != null) {
            System.Console.Write(curr.data + " ");
            curr = curr.next;
        }
    }

    static void Main(string[] args) {
		
    	// Create a hard-coded linked list:
		// 1 -> 3 -> 4
        Node head = new Node(1);
        head.next = new Node(3);
        head.next.next = new Node(4);

        // Create a loop
    	head.next.next.next = head.next;
        removeLoop(head);
        printList(head);
    }
}

//Driver Code Ends
JavaScript 
//Driver Code Starts
// JavaScript program Using Floyd's Cycle Detection Algorithm 

class Node {
    constructor(x) {
        this.data = x;
        this.next = null;
    }
}
//Driver Code Ends


// Function to detect and remove loop in the linked list
function removeLoop(head) {

    // If list is empty or has only one node without loop
    if (head == null || head.next == null) return;

    let slow = head, fast = head;

    // Move slow and fast 1 and 2 steps 
    // ahead respectively
    slow = slow.next;
    fast = fast.next.next;

    // Search for loop using slow and fast pointers
    while (fast != null && fast.next != null) {
        if (slow == fast) break;

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

    // If loop exists
    if (slow == fast) {
        slow = head;

        // If the loop starts at the head of the list
        if (slow != fast) {
            while (slow.next != fast.next) {
                slow = slow.next;
                fast = fast.next;
            }

            // Remove the loop
            fast.next = null;
        } else {
        
            // Special case when loop starts at the head
            while (fast.next != slow) {
                fast = fast.next;
            }
            fast.next = null;
        }
    }
}


//Driver Code Starts
function printList(curr) {
    let result = [];
    while (curr != null) {
        result.push(curr.data);
        curr = curr.next;
    }
    console.log(result.join(' '));
}

// Create a hard-coded linked list:
// 1 -> 3 -> 4
let head = new Node(1);
head.next = new Node(3);
head.next.next = new Node(4);

// Create a loop
head.next.next.next = head.next;

removeLoop(head);
printList(head);

//Driver Code Ends

Output
1 3 4

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

For more details about the working & proof of this algorithm, Please refer to this article, How does Floyd’s Algorithm works.


Next Article
Detect and Remove Loop in Linked List

K
kartik
Improve
Article Tags :
Practice Tags :

Similar Reads

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