Linked list cycle

problem [https://leetcode.com/problems/linked-list-cycle/ 141. Linked List Cycle].

Problem description
Given, 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  pointer. Internally,  is used to denote the index of the node that tail's   pointer is connected to. Note that  is not passed as a parameter.

Return  if there is a cycle in the linked list. Otherwise, return.


 * 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.
 * is  or a valid index in the linked-list.
 * is  or a valid index in the linked-list.

Can you solve it using  (i.e. constant) memory?
 * Follow up

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 . 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.