# 142. Linked List Cycle II

Given a linked list, determine if it has a cycle in it.

To represent a cycle in the given linked list, we use an integer pos which represents the position (0-indexed) in the linked list where tail connects to. If pos is -1, then there is no cycle in the linked list.

Example 1:

Input: head = [3,2,0,-4], pos = 1
Output: true
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: true
Explanation: There is a cycle in the linked list, where tail connects to the first node.

Example 3:

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

Follow up:

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

# Solution

Approach 1: Hash table.

Approach 2: Two pointers.

# Code (Python)

Approach 1:

Approach 2:

# Code (C++)

Approach 1:

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
// Hash table.
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        unordered_set<ListNode*> visited;
        ListNode *curr = head;
        while (curr)
        {
            if (visited.find(curr) != visited.end())
                return curr;
            else
                visited.insert(curr);
            curr = curr->next;
        }
        return NULL;
    }
};

Approach 2:

// Two pointers. When fast and slow pointers meet, slow pointer
// has moved x steps while fast pointer has moved 2x steps.
// Now let slow pointer starts from the list head and fast pointer
// keeps moving with one step each time. They will meet in the same
// node again after x steps. Meanwhile, the first node they meet is
// where the cycle begins.
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode *slow = head;
        ListNode *fast = head;
        while (fast && fast->next)
        {
            slow = slow->next;
            fast = fast->next->next;
            if (slow == fast)
                break;
        }
        slow = head;
        while (fast && fast->next)
        {
            if (slow == fast)
                return slow;
            slow = slow->next;
            fast = fast->next;
        }
        return NULL;
    }
};