top of page
Search

Given the head of a linked list, return the node where the cycle begins. If there is no cycle, return null.

There is a cycle in a linked list if there is some node in the list that can be reached again by continuously following the next pointer. Internally, pos is used to denote the index of the node that tail's next pointer is connected to (0-indexed). It is -1 if there is no cycle. Note that pos is not passed as a parameter.

Do not modify the linked list.

Example 1:

```Input: head = [3,2,0,-4], pos = 1
Output: tail connects to node index 1
Explanation: There is a cycle in the linked list, where tail connects to the second node.
```

Example 2:

```Input: head = [1,2], pos = 0
Output: tail connects to node index 0
Explanation: There is a cycle in the linked list, where tail connects to the first node.
```

Example 3:

```Input: head = [1], pos = -1
Output: no cycle
Explanation: There is no cycle in the linked list.
```

Constraints:

• The number of the nodes in the list is in the range [0, 104].

• -105 <= Node.val <= 105

• pos is -1 or a valid index in the linked-list.

Explanation:

We have to solve two parts:

1. Whether a cycle exists or not?

2. What is the entry point?

To Solved whether a cycle exists or not, we use Cycle detection theorem. Where we use two pointers Fast and Slow, they move at different speeds. And if they meet at some point, then cycle exists.

To solve the entry point, we are going to use a simple mathematical knowledge,

Assume the distance from head to the start of the loop is x1 The distance from the start of the loop to the point fast and slow meet is x2 The distance from the point fast and slow meet to the start of the loop is x3 What is the distance fast moved?

x1 + x2 + x3 + x2

What is the distance slow moved?

x1 + x2

And their relationship?

x1 + x2 + x3 + x2 = 2 (x1 + x2)

Solving this,

2x2+x1+x3 = 2x2+2x1
x3 = 2x1-x1
x3=x1

so, x3 (distance from slow and fast met to entry point of cycle) = x1 (distance from head of linked list to entry point of cycle)

We use two pointers s and s2 to move both the distance, and meeting point is the solution.

Solution:

```/**
* class ListNode {
*     int val♠
*     ListNode next;
*     ListNode(int x) {
*         val = x;
*         next = null;
*     }
* }
*/
public class Solution {

while(fast!=null && fast.next!=null)
{
fast = fast.next.next;
slow = slow.next;

if(fast == slow)
{
while(slow2!=slow)
{
slow = slow.next;
slow2 = slow2.next;
}
return slow;
}
}
return null;
}
}```