Cycle Detection in a Singly Linked List
You have given a Singly Linked List of integers, determine if it forms a cycle or not.

A cycle occurs when a node's next points back to a previous node in the list. The linked list is no longer linear with a beginning and end—instead, it cycles through a loop of nodes.

Note: Since, it is binary problem, there is no partial marking. Marks will only be awarded if you get all the test cases correct.

Input format :

The first line of each test case contains the elements of the singly linked list separated by a single space and terminated by -1 and hence -1 would never be a list element. The second line contains the integer position "pos" which represents the position (0-indexed) in the linked list where tail connects to. If "pos" is -1, then there is no cycle in the linked list.

Output format :

The only line of output contains 'true' if linked list has a cycle or 'false' otherwise. You don't have to explicitly print by yourself. It has been taken care of.

Constraints :

0

Question

Cycle Detection in a Singly Linked List

You have given a Singly Linked List of integers, determine if it forms a cycle or not.

A cycle occurs when a node's next points back to a previous node in the list. The linked list is no longer linear with a beginning and end—instead, it cycles through a loop of nodes.

Note: Since, it is binary problem, there is no partial marking. Marks will only be awarded if you get all the test cases correct.

Input format :

The first line of each test case contains the elements of the singly linked list separated by a single space and terminated by -1 and hence -1 would never be a list element.

The second line contains the integer position "pos" which represents the position (0-indexed) in the linked list where tail connects to. If "pos" is -1, then there is no cycle in the linked list.

Output format :

The only line of output contains 'true' if linked list has a cycle or 'false' otherwise.

You don't have to explicitly print by yourself. It has been taken care of.

Constraints :

0 <= N <= 10^6
-1 <= pos < N
-10^9 <= data <= 10^9 and data != -1

Where 'N' is the size of the singly linked list, "pos" represents the position (0-indexed) in the linked list where tail connects to and "data" is the Integer data of singly linked list.

Time Limit: 1 sec

Note :

Try to solve this problem in O(N) Time Complexity and O(1) space Complexity

Accepted Answer

It is a standard problem in the linked list we can solve it using two pointers one moves one step at a time and the other two steps at a time. For each time we check whether they are the same. And this goes up to NULL is reached.

Accepted Answer

Outer And Inner Loop

We are going to have two loops outer-loop and inner-loop

Maintain a count of the number of nodes visited in outer-loop.
For every node of the outer-loop, start the inner loop from head.
If the inner-loop visits the node next to the outer-loop node, then return true, else repeat the process for the next iteration of outer-loop.
If outer-loop reaches the end of list or null, then return false.

Space Complexity: O(1)Explanation:

O(1).

Constant space is used.

Time Complexity: O(1)Explanation:

O(N*N), where N is the total number of nodes.

For every iteration of outer-loop, we are iterating the linked-list again.

Accepted Answer

Look Up Table Approach

We are going to maintain a lookup table(a Hashmap) that basically tells if we have already visited a node or not, during the course of traversal.

Visit every node one by one, until null is not reached
Check if the current node is present in the loop up table, if present then there is a cycle and will return true, otherwise, put the node reference into the lookup table and repeat the process.
If we reach at the end of the list or null, then we can come out of the process or loop and finally, we can say the loop doesn't exist.

Space Complexity: O(1)Explanation:

O(N), where N is the total number of nodes.

At most we will put all the N nodes into the look up table.

Time Complexity: O(1)Explanation:

O(N), where N is the total number of nodes.

We would be visiting every node once, as soon as we encounter a multiple visit on a node, then we will stop execution.

Accepted Answer

Slow And Fast Pointer Approach

The idea is to have 2 pointers: slow and fast. Slow pointer takes a single jump and corresponding to every jump slow pointer takes, fast pointer takes 2 jumps. If there exists a cycle, both slow and fast pointers will reach the exact same node. If there is no cycle in the given linked list, then fast pointer will reach the end of the linked list well before the slow pointer reaches the end or null.
Initialize slow and fast at the beginning.
Start moving slow to every next node and moving fast 2 jumps, while making sure that fast and its next is not null.
If after adjusting slow and fast, if they are referring to the same node, there is a cycle otherwise repeat the process
If fast reaches the end or null then the execution stops and we can conclude that no cycle exists.

Space Complexity: O(1)Explanation:

O(1).

Constant space is used.

Time Complexity: O(1)Explanation:

O(N), where N is the total number of nodes.

If a cycle is not present then the fast pointer will reach ‘NULL ’in O(N / 2) time and if there is a cycle then the fast pointer will meet the slow pointer in a maximum of O(N) time. Hence the complexity will be O(N).

You have given a Singly Linked List of integers, determine if it forms a cycle or not.

A cycle occurs when a node's next points back to a previous node in the list. The linked list is no longer linear with a beginning and end—instead, it cycles through a loop of nodes.

Note: Since, it is binary problem, there is no partial marking. Marks will only be awarded if you get all the test cases correct.

Input format :

Output format :

Constraints :

Note :

Top 42Gears Mobility Systems Mts1 interview questions & answers

Popular interview questions of Mts1