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

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

**141. Linked List Cycle**

**– Leetcode Solution**.

**Problem**

Given `head`

, the head of a linked list, determine if the linked list has a cycle in it.

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. **Note that ****pos**** is not passed as a parameter.**

Return `true`

*if there is a cycle in the linked list*. Otherwise, return `false`

.

**Example 1 :**

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

**Example 2 :**

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

### E**xample 3 :**

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

**Constraints**

- The number of the nodes in the list is in the range
`[0, 104]`

. `-10`

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

is`-1`

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

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

**Linked List Cycle – Leetcode Solution**

**Linked List Cycle – Leetcode Solution**

**141. Linked List Cycle** – Solution in Java

**– Solution in Java**

**141. Linked List Cycle**/** * Definition for singly-linked list. * class ListNode { * int val; * ListNode next; * ListNode(int x) { * val = x; * next = null; * } * } */ public class Solution { public boolean hasCycle(ListNode head) { ListNode slow = head, fast = head; while (fast != null && fast.next != null) { slow = slow.next; fast = fast.next.next; if (slow == fast) return true; } return false; } }

**141. Linked List Cycle** – Solution in C++

**C++**

**– Solution in****141. Linked List Cycle**/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public: bool hasCycle(ListNode *head) { ListNode* fast = head, *slow=head; while(fast!=NULL and fast->next!=NULL){ fast = fast->next->next; slow = slow->next; if(fast==slow){return true;} } return false; } };

**141. Linked List Cycle** – Solution in Python

**Python**

**– Solution in****141. Linked List Cycle**# Definition for singly-linked list. # class ListNode(object): # def __init__(self, x): # self.val = x # self.next = None class Solution(object): def hasCycle(self, head): """ :type head: ListNode :rtype: bool """ try: slow = head fast = head.next while slow is not fast: slow = slow.next fast = fast.next.next return True except: return False

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