• 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

Max Sum in circularly situated Values

Find an index i such that Arr [i] = i in array of n distinct integers sorted in ascending order.

LeetCode: Container With Most Water

Edit Distance ( Dynamic Programming )

Code Chef PRGIFT Solution

The greedy coins game Dynamic Programming

Wrong Directions given find minimum moves so that he can reach to the destination

Search element in a matrix with all rows and columns in sorted order

Find next greater number with same set of digits

Check a String is SUBSEQUENCE of another String Find Minimum length for that ( DNA Matching )

There are N nuts and N bolts, u have to find all the pairs of nuts and bolts in minimum no. of iteration

25 horses 5 tracks Find 3 fastest puzzle

Amazon Interview Experience – SDE Chennai

Find two non repeating elements in an array of repeating elements

Binary Tree in Java

Longest Increasing Subsequence

Binary Tree Isomorphic to each other

HackeEarth Flipkart’s Drone

Maximum path sum between two leaves

Given array of 0’s and 1’s. All 0’s are coming first followed by 1’s. find the position of first 1

CodeChef’ RRCOPY

SAP Off Campus Hiring_ March 2015 Sample Questions

DFS (Depth First Search)

Leetcode: Merge Intervals

Printing Longest Common Subsequence

VMWare Openings

Maximum sum contiguous subarray of an Array

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

Maximum occurred Smallest integer in n ranges

Sequence Finder Dynamic Programming

Copyright © 2025 · Genesis Framework · WordPress · Log in