Linked List Cycle | & ||

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

Example

Given -21->10->4->5, tail connects to node index 1, return true.

分析：

方法一：使用HashSet保存每一个节点。

/**
 * Definition for ListNode.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int val) {
 *         this.val = val;
 *         this.next = null;
 *     }
 * }
 */ 
public class Solution {
    /**
     * @param head: The first node of linked list.
     * @return: True if it has a cycle, or false
     */
    public boolean hasCycle(ListNode head) {  
        if (head == null) return false;
        HashSet<ListNode> set = new HashSet<ListNode>();
        while (head != null) {
            if (set.contains(head)) {
                return true;
            }
            set.add(head);
            head = head.next;
        }
        return false;
    }
}

方法二：

设置两个指针指向单链表的head, 然后开始遍历，第一个指针走一步，第二个指针走两步，如果没有环，它们会直接走到底，如果有环，这两个指针一定会相遇。

public class Solution {
    public boolean hasCycle(ListNode head) {  
        if (head == null) return false;
        ListNode slow = head;
        ListNode quick = head.next;
        while (slow != null && quick != null) {
            if (slow == quick) return true;
            slow = slow.next;
            quick = quick.next;
            if (quick != null) {
                quick = quick.next;
            }
        }
        return false;
    }
}

Linked List Cycle II

Given a linked list, return the node where the cycle begins.

If there is no cycle, return null.

Example

Given -21->10->4->5, tail connects to node index 1，return 10。

方法一：

使用HashSet

/**
 * Definition for ListNode.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int val) {
 *         this.val = val;
 *         this.next = null;
 *     }
 * }
 */ 
public class Solution {
    /**
     * @param head: The first node of linked list.
     * @return: The node where the cycle begins. 
     *           if there is no cycle, return null
     */
    public ListNode detectCycle(ListNode head) {  
        if (head == null || head.next == null) return null;
        
        Set<ListNode> set = new HashSet<ListNode>();
        
        while (head!= null) {
            if (set.contains(head)) {
                return head;
            } else {
                set.add(head);
            }
            head = head.next;
         }
         return null;
    }
}

方法二：

public static ListNode detectCycle(ListNode head) {
    ListNode slow = head;
    ListNode fast = head;

    while (true) {
        if (fast == null || fast.next == null) {
            return null;    //遇到null了，说明不存在环
        }
        slow = slow.next;
        fast = fast.next.next;
        if (fast == slow) {
            break;    //第一次相遇在Z点
        }
    }

    slow = head;    //slow从头开始走，
    while (slow != fast) {    //二者相遇在Y点，则退出
        slow = slow.next;
        fast = fast.next;
    }
    return slow;
}

分析：上面的代码为何能够找到环的起始位置？

假设环的长度是 m, 进入环前经历的node的个数是 k , 那么，假设经过了时间 t，那么速度为2 的指针距离起始点的位置是:  k + (2t - k) % m = k + (2t - k) - xm . 同理，速度为1的指针距离起始点的位置是 k + (t - k) % m = k + (t - k) - ym。

如果 k + (2t - k) - xm =  k  + (t - k) - ym ，可以得到 t = m (x - y)。 那么当 t 最小为m的时候，也就是说，两个指针相聚在距离环起始点 m - k 的环内。换句话说，如果把一个指针移到链表的头部，然后两个指针都以 1 的速度前进，那么它们经过 k 时间后，就可以在环的起始点相遇。

Reference: http://www.cnblogs.com/hiddenfox/p/3408931.html

转载请注明出处：cnblogs.com/beiyeqingteng/