In this post, we are going to solve the** 142. Linked List Cycle II** problem of Leetcode. This problem **142. Linked List Cycle II** is a Leetcode

**medium**level problem. Let’s see the code,

**142. Linked List Cycle II**

**– Leetcode Solution**.

**Problem**

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, 10`

.^{4}] `-10`

^{5}<= Node.val <= 10^{5}`pos`

is`-1`

or a**valid index**in the linked-list.

Now, let’s see the code of **142. Linked List Cycle II** – Leetcode Solution.

**Linked List Cycle II – Leetcode Solution**

**Linked List Cycle II – Leetcode Solution****142. Linked List Cycle II** – Solution in Java

**– Solution in Java**

**142. Linked List Cycle II**/** * Definition for singly-linked list. * class ListNode { * int val; * ListNode next; * ListNode(int x) { * val = x; * next = null; * } * } */ public class Solution { public ListNode intersectionPointInCycle(ListNode head){ if(head == null) return null; ListNode slow = head; ListNode fast = head; while(fast != null && fast.next != null){ slow = slow.next; fast = fast.next.next; if(slow == fast){ return slow; } } return null; } public ListNode detectCycle(ListNode head) { if(head == null) return null; ListNode slow = head; ListNode fast = intersectionPointInCycle(head); if(fast == null) return null; while(slow != fast){ slow = slow.next; fast = fast.next; } return slow; } }

**142. Linked List Cycle II** – Solution in C++

**C++**

**– Solution in****142. Linked List Cycle II**/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public: ListNode *detectCycle(ListNode *head) { if(head==NULL) { return NULL; } if(head->next==NULL) { return NULL; } ListNode* slow=head; ListNode* fast=head; while(fast->next!=NULL && fast->next->next!=NULL) { slow=slow->next; fast=fast->next->next; if(slow==fast) { ListNode* temp=head; while(temp!=slow) { temp=temp->next; slow=slow->next; } return temp; } } return NULL; } };

**142. Linked List Cycle II** **– Solution in **Python

**142. Linked List Cycle II****Python**

**– Solution in**# Definition for singly-linked list. # class ListNode: # def __init__(self, x): # self.val = x # self.next = None class Solution: def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]: e=s=f=head while f and f.next: s=s.next f=f.next.next if s==f: while s!=e: s=s.next e=e.next return e return None

**Note:** This problem **142. Linked List Cycle II** is generated by **Leetcode **but the solution is provided by **CodingBroz**. This tutorial is only for **Educational** and **Learning** purpose.