# Leetcode – Linked List Cycle

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

Analysis

If we have 2 pointers - fast and slow. It is guaranteed that the fast one will meet the slow one if there exists a circle.

The problem can be demonstrated in the following diagram:

Java Solution

```public class Solution { public boolean hasCycle(ListNode head) { ListNode fast = head; ListNode slow = head;   while(fast != null && fast.next != null){ slow = slow.next; fast = fast.next.next;   if(slow == fast) return true; }   return false; } }```
Category >> Algorithms
If you want someone to read your code, please put the code inside <pre><code> and </code></pre> tags. For example:
```<pre><code>
String foo = "bar";
</code></pre>
```
• গোলাম মোস্তফা রুমি

Here is my code:

class Solution {
public:
else{
}
}
return false;
}
};

• Prakash Jha

when will fast or fast->next become null??

• Marina

``` public class LinkedListCycle {```

``` public boolean check(LinkedList list) { Node fast = list.getHead(); Node slow = list.getHead(); ```

``` while (fast != null && fast.getNext() != null && fast.getNext().getNext() != null) { if (slow == fast) { return true; } } return false; } } ```

• Tayyab

Oh yes, the two B’s are the same node! That is what I was skipping.
Thank you so much! This bugged me for a long time.

• Vani

Since it is cycle , next iternation, F jumps by skipping one element. So it skips, B and then goes to C. Remember that E connects back to B and next of E is B, next of B is C.

• Tayyab

After F=E, how does it get to C again, if it’s skipping to the end of the list?
And even if it is starting form the beginning again, shouldn’t it again jump to A instead of C?

• tm

If you compare two nodes using boolean operators will it return the correct value? Shouldn’t you implement your own equal method for nodes?

• Carlos Gomez

Does this make sense?

A -> B -> C -> D -> E -> B

iter 1
S = A
F = C

iter 2
S = B
F = E

iter 3
S = C
F = C

Cycle detected, return true

• Tayyab

This confuses me, what if there is a sixth element in the list that is looping to the third element?
A->B->C->D->E->B

fast will never reach the second B and the loop will terminate without detecting the loop.
This solution is on so many sites, why can’t people see it?
Or may be I’m catching something wrong?

• ryanlr

Thanks! fixed.

• ryanlr

Yes, deleted.

• dd

The naive version is wrong?