LeetCode OJ - Linked List Cycle I and II

链表有环无环的判断以及环的第一个节点的检测问题。编程之美上面也有。

思路极为简单：

1. 是否有环，通过快、慢两个指针从头一直走，快的每次走两步，慢的每次走一步，如果快的最后有遇到null，说明没有环；如果快的最后和慢的同时走到某个节点，则说明有环。

2. 环的第一个节点，用两个指针，一个从链表的头部开始，一个从快慢两个指针的同时指向的那个节点开始，每次走一步，当这两个指针同时到达一个节点A时，A就是这个环的第一个节点，这是有个数学关系在里头，可以自行推倒。

下面是已AC代码。

/**
     * detect the first node of the cycle if it has cycle
     * @param head
     * @return the first node or null
     */
    public ListNode detectCycle(ListNode head)
    {
        if(head == null  || head.next == null)
            return null;
        
        //use a faster pointer and a slower pointer, to find the coincident node;
        ListNode faster = head;
        ListNode slower = head;
        ListNode con = null;
        while(faster!=null && faster.next!=null)
        {
            faster = faster.next.next;
            slower = slower.next;
            if(faster == slower)
            {
                con = faster;
                slower = head;
                break;
            }
        }
        //if there is no cycle, directly return null
        if(con == null)
            return null;
        
        //find the first node of the cycle, the one that both reached at the same time
        while(slower!=faster)
        {
            slower = slower.next;
            faster = faster.next;
        }
        
        return faster;
    }
    /**
     * determine if it has a cycle in it
     * @param head
     * @return
     */
    public boolean hasCycle(ListNode head){
        if(head == null || head.next == null)
            return false;
        
        //use a faster pointer and a slower pointer, to find whether they are coincident in one node;
        ListNode faster = head;
        ListNode slower = head;
        
        while(faster!=null && faster.next!=null)
        {
            faster = faster.next.next;
            slower = slower.next;
            if(faster == slower)
                return true;
        }
        return false;
    }