[leetcode]Linked List Cycle II

Linked List Cycle II

Given a linked list, return the node where the cycle begins. If there is no cycle, return null.

Follow up:
Can you solve it without using extra space?

算法

思路1：

最土的双指针算法，先检测是否有环，如果有，则用一只指针detect逐个定位节点，用另一个指针loop，循环测试。时间复杂度为O(n*n)，空间为O(1)，but

有一个疑问：

如何防止死循环？

不实现了，比较简单。

思路2：

同[leetcode]Linked List Cycle的思路2，hash，一次遍历，代码简单，空间复杂度O(n)，时间复杂度O(n)

public class Solution {
    public ListNode detectCycle(ListNode head) {
        if(head == null) return null;
        ListNode tem = new ListNode(0);
        tem.next = head;
        Map<ListNode,ListNode> hash = new HashMap<ListNode,ListNode>();
        while(true){
            if(tem.next == null) return null;
            if(hash.get(tem.next) != null) return tem.next;
            hash.put(tem.next,tem);
            tem = tem.next;
        }
    }
}

思路3：

同样采用快慢指针，测试到有环，则慢指针回到head，快指针还指向第一次相遇的节点，然后两个指针齐步走，当两指针再次相遇的时候，则相遇点即为环的起点，时间复杂度O(n)，空间复杂度O(1)，但是需要两遍遍历。

这个算法有点高大上，在leetcode中有人专门用一个专题进行了详细的讲解(链接偶尔打不开)，也可以参考 Floyd’s cycle finding algorithm我还没看，哈哈

不啰嗦，代码如下:

public class Solution {
    public ListNode detectCycle(ListNode head) {
        if(head == null) return null;
        ListNode fast = head;
        ListNode slow = head;
        while(true){
            if(fast.next == null || fast.next.next == null) return null;
            fast = fast.next.next;
            slow = slow.next;
            if(fast == slow){
                slow = head;
                break;
            }
        }
        while(fast != slow){
            fast = fast.next;
            slow = slow.next;
        }
        return fast;
    }
}