141. Linked List Cycle

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

Follow up:

Can you solve it without using extra space?

访问过的节点，值直接设置为其hashcode了，这样再次访问就能检测到。

 public static boolean hasCycle(ListNode head)
	{
		if(head==null||head.next==null)
			return false;
		ListNode node=head.next;
		while(node!=null)
		{
			if(node.val==node.hashCode())
				return true;
			node.val=node.hashCode();
			node=node.next;
		}
		
		return false;
	}

上面的方法虽然空间复杂度O(1)，这题用不到节点值，可以修改节点值，节点值要使用的话还是下面的方法好，

摘自：https://leetcode.com/articles/linked-list-cycle/

Approach #2 (Two Pointers) [Accepted]

Intuition

Imagine two runners running on a track at different speed. What happens when the track is actually a circle?

Algorithm

The space complexity can be reduced to $O(1)$ by considering two pointers at different speed - a slow pointer and a fast pointer. The slow pointer moves one step at a time while the fast pointer moves two steps at a time.

If there is no cycle in the list, the fast pointer will eventually reach the end and we can return false in this case.

Now consider a cyclic list and imagine the slow and fast pointers are two runners racing around a circle track. The fast runner will eventually meet the slow runner. Why? Consider this case (we name it case A) - The fast runner is just one step behind the slow runner. In the next iteration, they both increment one and two steps respectively and meet each other.

How about other cases? For example, we have not considered cases where the fast runner is two or three steps behind the slow runner yet. This is simple, because in the next or next's next iteration, this case will be reduced to case A mentioned above.

public boolean hasCycle(ListNode head) {
    if (head == null || head.next == null) {
        return false;
    }
    ListNode slow = head;
    ListNode fast = head.next;
    while (slow != fast) {
        if (fast == null || fast.next == null) {
            return false;
        }
        slow = slow.next;
        fast = fast.next.next;
    }
    return true;
}