floyd's cycle detection algorithm - Wikitechy https://www.wikitechy.com/interview-questions/tag/floyds-cycle-detection-algorithm/ Interview Questions Thu, 16 Sep 2021 12:32:43 +0000 en-US hourly 1 https://wordpress.org/?v=6.9.4 https://www.wikitechy.com/interview-questions/wp-content/uploads/2025/10/cropped-wikitechy-icon-32x32.png floyd's cycle detection algorithm - Wikitechy https://www.wikitechy.com/interview-questions/tag/floyds-cycle-detection-algorithm/ 32 32 How to detect a cycle in a linked list ? https://www.wikitechy.com/interview-questions/data-structure/how-to-detect-a-cycle-in-a-linked-list/ https://www.wikitechy.com/interview-questions/data-structure/how-to-detect-a-cycle-in-a-linked-list/#respond Tue, 13 Jul 2021 16:48:05 +0000 https://www.wikitechy.com/interview-questions/?p=497

How to detect a cycle in a linked list ?

  • A linked list is said to contain a cycle if any node is visited more than once.
How do you detect a cycle in a linked list

Method 1 – Using Hashing

  • Traverse the given list.
  • Insert each encountered node into a hash table.
  • If the current already present ,that means the cycle is present or not.

Sample code

#include <iostream>
#include <unordered_set>
using namespace std;

// Data Structure to store a linked list node
struct Node
{
    int dt;
    Node* next;
};

// Helper function to create a new node with the given data and
// pushes it onto the front of the list
void push(Node*& headRef, int dt)
{
    // create a new linked list node from heap
    Node* newNode = new Node;

    newNode->dt = dt;
    newNode->next = headRef;
    headRef = newNode;
}

// Function to detect Cycle in a linked list using Hashing
bool detectcyc(Node *head)
{
    Node *current = head;
    unordered_set<Node*> set;

    // traverse the list
    while (current)
    {
        // return false if we already have seen this node before
        if (set.find(current) != set.end())
            return true;

        // insert current node into the set
        set.insert(current);

        // move to the next node
        current = current->next;
    }

    // we reach here if list does not contain any cycle
    return false;
}

// Detect Cycle in a linked list
int main()
{
    // input keys
    int k[] = { 1, 2, 3, 4, 5 };
    int n = sizeof(k) / sizeof(k[0]);

    Node* head = nullptr;
    for (int i = n - 1; i >= 0; i--)
        push(head, k[i]);

    // insert cycle
    head->next->next->next->next->next = head->next->next;

    if (detectcyc(head))
        cout << "Cycle Found";
    else
        cout << "No Cycle Found";

    return 0;
}

Output

Cycle Found

Method 2 – Floyd’s Cycle Detection Algorithm

  • Use two pointers, which move through the sequence at different speed.
  • The fast pointer moves twice as quickly as the slow pointer.
  • Here the distance between the two pointers increased by 1 at each step.
  • If these pointers meet at same node then there is a loop else linked list doesn’t have loop.

Sample Code

#include <iostream>
#include <unordered_set>
using namespace std;

// Data Structure to store a linked list node
struct Node
{
    int dt;
    Node* next;
};

// Helper function to create a new node with the given data and
// pushes it onto the front of the list
void push(Node*& headRef, int dt)
{
    // create a new linked list node from heap
    Node* nNode = new Node;

    nNode->dt = dt;
    nNode->next = headRef;
    headRef = nNode;
}

// Function to detect Cycle in a linked list using
// Floyd’s Cycle Detection Algorithm
bool dcycle(Node *head)
{
    // take two pointers - slow and fast
    Node *slow = head, *fast = head;

    while (fast && fast->next)
    {
        // move slow by one pointer
        slow = slow->next;

        // move fast by two pointers
        fast = fast->next->next;

        // if they meet any any node, linked list contains a cycle
        if (slow == fast)
            return true;
    }

    // we reach here if slow & fast pointer do not meet
    return false;
}

// Detect Cycle in a linked list using Floyd’s Cycle Detection Algorithm
int main()
{
    // input keys
    int k[] = { 1, 2, 3, 4, 5 };
    int n = sizeof(k) / sizeof(k[0]);

    Node* head = nullptr;
    for (int i = n - 1; i >= 0; i--)
        push(head, k[i]);

    // insert cycle
    head->next->next->next->next->next = head->next->next;

    if (dcycle(head))
        cout << "Cycle Found";
    else
        cout << "No Cycle Found";

    return 0;
}

Output

Cycle Found
]]> https://www.wikitechy.com/interview-questions/data-structure/how-to-detect-a-cycle-in-a-linked-list/feed/ 0 Detect loop in a linked list ? https://www.wikitechy.com/interview-questions/data-structure/detect-loop-in-a-linked-list/ https://www.wikitechy.com/interview-questions/data-structure/detect-loop-in-a-linked-list/#respond Tue, 13 Jul 2021 11:08:43 +0000 https://www.wikitechy.com/interview-questions/?p=473

Detect loop in a linked list ?

  • There are two ways to detect loop in linked list or not.
Detect Loop in a Linked List

Method 1:

  • Traverse through each node till end , tracking visited node using Hash map.
  • If you find node that is already visited, then there is a loop in LinkedList
  • If you reach till end while traversing then there is no loop in LinkedList
using namespace std; 

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

void push(struct Node** head_ref, int new_data) 
{ 

	struct Node* new_node = new Node; 

	
	new_node->data = new_data; 

	/* link the old list off the new node */
	new_node->next = (*head_ref); 

	/* move the head to point to the new node */
	(*head_ref) = new_node; 
} 

// Returns true if there is a loop in linked list 
// else returns false. 
bool detectLoop(struct Node *h) 
{ 
	unordered_set<Node *> s; 
	while (h != NULL) 
	{ 
		// If this node is already present 
		// in hashmap it means there is a cycle 
		// (Because you we encountering the 
		// node for the second time). 
		if (s.find(h) != s.end()) 
			return true; 

		// If we are seeing the node for 
		// the first time, insert it in hash 
		s.insert(h); 

		h = h->next; 
	} 

	return false; 
} 

/* Drier program to test above function*/
int main() 
{ 
	/* Start with the empty list */
	struct Node* head = NULL; 

	push(&head, 21); 
	push(&head, 14); 
	push(&head, 5); 
	push(&head, 10); 

	/* Create a loop for testing */
	head->next->next->next->next = head; 

	if (detectLoop(head)) 
		cout << "Loop found"; 
	else
		cout << "No Loop"; 

	return 0; 
}

Output:

Loop found

Method 2:

  • Efficient approach for this problem would be Floyd’s cycle detection algorithm, so steps for this algorithm would be:
    • Use two pointer fastPtr and slowPtr and initialize both to head of linkedlist
    • Move fastPtr by two nodes and slowPtr by one node in each iteration.
    • If fastPtr and slowPtr meet at some iteration , then there is a loop in linkedlist.
    • If fastPtr reaches to the end of linkedlist without meeting slow pointer then there is no loop in linkedlist (i.e fastPtr->next or fastPtr->next->next become null).
// C program to detect loop in a linked list 
#include<stdio.h> 
#include<stdlib.h> 
/* Link list node */
struct Node 
{ 
	int data; 
	struct Node* next; 
}; 

void push(struct Node** head_ref, int new_data) 
{ 
	/* allocate node */
	struct Node* new_node = 
		(struct Node*) malloc(sizeof(struct Node)); 

	/* put in the data */
	new_node->data = new_data; 

	/* link the old list off the new node */
	new_node->next = (*head_ref); 

	/* move the head to point to the new node */
	(*head_ref) = new_node; 
} 

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) 
		{ 
		printf("Found Loop"); 
		return 1; 
		} 
	} 
	return 0; 
} 

/* Drier program to test above function*/
int main() 
{ 
	/* Start with the empty list */
	struct Node* head = NULL; 

	push(&head, 10); 
	push(&head, 4); 
	push(&head, 5); 
	push(&head, 10); 

	/* Create a loop for testing */
	head->next->next->next->next = head; 
	detectloop(head); 

	return 0; 
}

Output:

Found Loop
]]> https://www.wikitechy.com/interview-questions/data-structure/detect-loop-in-a-linked-list/feed/ 0