• Skip to primary navigation
  • Skip to content
  • Skip to primary sidebar
  • Skip to secondary sidebar

GoHired

Interview Questions asked in Google, Microsoft, Amazon

Join WeekEnd Online Batch from 4-April-2020 on How to Crack Coding Interview in Just 10 Weeks : Fees just 20,000 INR

  • Home
  • Best Java Books
  • Algorithm
  • Internship
  • Certificates
  • About Us
  • Contact Us
  • Privacy Policy
  • Array
  • Stack
  • Queue
  • LinkedList
  • DP
  • Strings
  • Tree
  • Mathametical
  • Puzzles
  • Graph

Find loop in Singly linked list

February 20, 2014 by Dhaval Dave

There are several ways to find loop in singly linked list,

Loop Node5 Next pointer is point to Node3 in Singly Linked List

1 ---- 2 ---- 3 ---- 4 ---- 5
              |_____________|
  • Hashmap
  • Floyd’s cycle detection Algorithm
  • Fast and Slow pointer


Hash Map Method

  1. Start Traversing Linked List
  2. Repeat 3, 4 untill LinkedList’s end
  3. Search current node’s address in HashMap, if its not there :
    Push current node’s address to Hash
    else If current node’s address is  found in HashMap :
    LinkedList contains loop,
  4. Come out of loop

Floyd’s Cycle Algorithm : This method is also dependent on Floyd’s Cycle detection algorithm.

1) Detect Loop using Floyd’s Cycle detection algo and get the pointer to a loop node.
2) Count the number of nodes in loop. Let the count be k.
3) Fix one pointer to the head and another to kth node from head.
4) Move both pointers at the same pace, they will meet at loop starting node.
5) Get pointer to the last node of loop and make next of it as NULL.

 Fast And Slow Pointer Method : There is another way is with fast and slow pointer ,
 Logic of Algorithm :
Say Two runner are running in circular field, One runner say RunnerA runs with 10KMPH ‘s speed and one say RunnerB with 15KMPH (faster than first RunnerA), in circular path after some N rounds RunnerB will sure overtake (cross) RunnerA (means they will meet).
Same logic we are using to find loop with fast pointer and slow pointer, if they meet then they are in circular path.

W’ll keep faster Pointer to move Two steps and slow as One step.

Once they meet, We need to find node which is causing Loop,
that we can find it with below logic.
as faster point is double as fast as slow pointer, When they meet, they will be equally far head and count of node in loop.
So Follow steps after we find loop.
  1.  Count the number of nodes in loop. Let the count be k.
  2. Fix one pointer to the head and another to kth node from head.
  3. Move both pointers at the same pace, they will meet at loop starting node.
  4. Get pointer to the last node of loop and make next of it as NULL.

Code is given below

struct node
{
    int data;
    struct node* next;
};
int detectLoop(struct node *list)
{
 struct node *slow_p = list, *fast_p = list;
 while (slow_p && fast_p && fast_p->next)
 {
 slow_p = slow_p->next;
 fast_p = fast_p->next->next;
 if (slow_p == fast_p) {
 return 1; //to indicate loop is there
 }
 return 0; //to indeciate that ther is no loop
 }
}
void removeLoop(struct node *loop_node, struct node *head)
{
    struct node *ptr1 = loop_node;
    struct node *ptr2 = loop_node;
 
    unsigned int k = 1, i;
    while (ptr1->next != ptr2)
    {
        ptr1 = ptr1->next;
        k++;
    }
 
    ptr1 = head;
 
    ptr2 = head;
    for (i = 0; i < k; i++)
      ptr2 = ptr2->next;
 
    while (ptr2 != ptr1)
    {
        ptr1 = ptr1->next;
        ptr2 = ptr2->next;
    }
 
    ptr2 = ptr2->next;
    while (ptr2->next != ptr1)
       ptr2 = ptr2->next;
 
    ptr2->next = NULL;
}

Method 2)

As we need to count the nodes in loop, it gives more cycles or iterations in given problem, We can think of solution where we don’t need to use K (number of nodes in Loop).

void detectAndRemoveLoop(Node *head)
{
    Node *slow = head;
    Node *fast = head->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;
        while (slow != fast->next)
        {
            slow = slow->next;
            fast = fast->next;
        }
 
        /* since fast->next is the looping point */
         /* remove loop */
         fast->next = NULL;
    }
}

 

Similar Articles

Filed Under: Adobe Interview Questions, Amazon Interview Question, Hacker Earth Questions, Interview Questions, Microsoft Interview Questions, problem Tagged With: Linked List

Reader Interactions

Primary Sidebar

Join WeekEnd Online/Offline Batch from 4-April-2020 on How to Crack Coding Interview in Just 10 Weeks : Fees just 20,000 INR

Join WeekEnd Online/Offline Batch from 4-April-2020

WhatsApp us

Secondary Sidebar

Custom Search

  • How I cracked AMAZON
  • LeetCode
  • Adobe
  • Amazon
  • Facebook
  • Microsoft
  • Hacker Earth
  • CSE Interview

Top Rated Questions

Find and print longest consecutive number sequence in a given sequence in O(n)

Possible sizes of bus to carry n groups of friends

Convert Decimal to Roman numbers / Romanizer HackerEarth Code

C++ OOPs Part2

TicTacToe Game As Asked in Flipkart

N Petrol bunks or City arranged in circle. You have Fuel and distance between petrol bunks. Is it possible to find starting point so that we can travel all Petrol Bunks

Given a sorted array and a number x, find the pair in array whose sum is closest to x

SAP Off Campus Hiring_ March 2015 Computer Skills

How strtok() Works

Urban Ladder Written Test.

CodeChef Code SGARDEN

Sort Stack in place

LeetCode : Word Search

Print Power Set of a Set

System Design: Designing a LLD for Hotel Booking

Word Break Problem

In Given LinkedList Divide LL in N Sub parts and delete first K nodes of each part

Top 10 Interviews Techniqes for Campus Interview in IIT NIT BITS for MTech

Find two non repeating elements in an array of repeating elements

Amazon Interview Experience – SDE Chennai

ADOBE Aptitude C Language Test

SAP Hiring Off-Campus General Aptitude

K’th Largest Element in BST when modification to BST is not allowed

Naurki.com Security Breach

Convert number to words java

C++ OOPs Part1

Maximum path sum between two leaves

Level order traversal in Spiral form

Stock Buy Sell to Maximize Profit

Binary Tree in Java

Copyright © 2025 · Genesis Framework · WordPress · Log in