Linked list cycle

LeetCode problem 141. Linked List Cycle.

## Problem description

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.

Example 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]`.
* `-105 <= Node.val <= 105`
* `pos` is `-1` or a **valid index** in the linked-list.

Follow up
Can you solve it using `O(1)` (i.e. constant) memory?

## Analysis

We can use two pointers: a **slow** pointer and a **fast** pointer.

* The fast pointer advances by 2 steps in each iteration.
* The slow pointer advances by 1 step in each iteration.

End the loop if:

* The fast pointer becomes `nullptr`. This means that the linked list has an end and no cycle.
* The fast pointer hits the slow pointer. This means that the fast pointer has went over the cycle and catches the slow pointer from behind.

### Time complexity

The time complexity is **O(n)**.

* If the linked list has no cycle, then after (n/2) iterations the fast pointer reaches the tail.
* If the linked list has a cycle, then the slow pointer will be caught up from behind by the fast pointer no later than when the slow pointer finishes going through the loop.

### Space complexity

The space complexity is **O(1)** since we only use a slow pointer and a fast pointer.

## Solution

### C++ solution

```
/\*\*
 \* 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) {
 if (head == nullptr) {
 return false;
 }

 ListNode \*slow = head, \*fast = head;
 while (fast != nullptr) {
 fast = fast->next;
 if (fast != nullptr) {
 fast = fast->next;
 }
 if (fast != nullptr) {
 slow = slow->next;
 }
 if (slow == fast) {
 return true;
 }
 }
 return false;
 }
};

```

### Java solution

```
/\*\*
 \* 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) {
 if (head == null) {
 return false;
 }

 ListNode slow = head, fast = head;
 while (fast != null) {
 fast = fast.next;
 if (fast != null) {
 fast = fast.next;
 }
 if (fast != null) {
 slow = slow.next;
 }
 if (slow == fast) {
 break;
 }
 }
 return slow == fast;
 }
};

```