linked list cycle done

Author: rampatra

src/main/java/com/leetcode/linkedlists/LinkedListCycleII.java

@@ -0,0 +1,73 @@
+package com.leetcode.linkedlists;
+
+/**
+ * Level: Medium
+ * Link: https://leetcode.com/problems/linked-list-cycle-ii/
+ * Description:
+ * Given a linked list, return the node where the cycle begins. If there is no cycle, return null.
+ *
+ * To represent a cycle in the given linked list, we use an integer pos which represents the position (0-indexed) in
+ * the linked list where tail connects to. If pos is -1, then there is no cycle in the linked list.
+ *
+ * Note: Do not modify the linked list.
+ *
+ * Example 1:
+ *
+ * Input: head = [3,2,0,-4], pos = 1
+ * Output: tail connects to node index 1
+ * Explanation: There is a cycle in the linked list, where tail connects to the second node.
+ *
+ *
+ * Example 2:
+ *
+ * Input: head = [1,2], pos = 0
+ * Output: tail connects to node index 0
+ * Explanation: There is a cycle in the linked list, where tail connects to the first node.
+ *
+ *
+ * Example 3:
+ *
+ * Input: head = [1], pos = -1
+ * Output: no cycle
+ * Explanation: There is no cycle in the linked list.
+ *
+ * Follow-up:
+ * Can you solve it without using extra space?
+ *
+ * @author rampatra
+ * @since 2019-08-18
+ */
+public class LinkedListCycleII {
+
+    /**
+     * Runtime: <a href="https://leetcode.com/submissions/detail/252786957/">0 ms</a>.
+     *
+     * @param head
+     * @return
+     */
+    public Node detectCycle(Node head) {
+        Node slow = head;
+        Node fast = head;
+
+        while (fast != null && fast.next != null) {
+            slow = slow.next;
+            fast = fast.next.next;
+            if (slow == fast) {
+                break;
+            }
+        }
+
+        if (fast == null || fast.next == null) {
+            return null;
+        } else {
+            slow = head;
+
+            while (slow != fast) {
+                slow = slow.next;
+                fast = fast.next;
+            }
+
+            return slow;
+        }
+    }
+}

src/main/java/com/rampatra/linkedlists/DetectAndRemoveLoop.java

@@ -34,6 +34,11 @@ public class DetectAndRemoveLoop {
      *   ii. Now, move both slow and fast pointer at same pace and where they meet is the starting point of the loop.
      *  iii. Lastly, to remove the loop make the next of the node (before the starting point of loop) to null.
      *
+     * Proof for Floyd's Cycle Detection: 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 -
+     * 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.
+     *
      * @param list
      * @param <E>
      * @return {@code true} if loop exists {@code false} otherwise.
@@ -58,7 +63,7 @@ public static <E extends Comparable<E>> boolean detectAndRemoveLoop(SingleLinked
         while (true) {
             slow = slow.next;
             fast = fast.next;
-            if (slow.next == fast.next) {
+            if (slow == fast) {
                 fast.next = null;
                 break;
             }
@@ -78,5 +83,23 @@ public static void main(String[] args) {
         linkedList.getNode(4).next = linkedList.getNode(2);
         System.out.println(detectAndRemoveLoop(linkedList));
         linkedList.printList();
+
+        linkedList = new SingleLinkedList<>();
+        linkedList.add(0);
+        linkedList.add(1);
+        linkedList.getNode(1).next = linkedList.getNode(0);
+        System.out.println(detectAndRemoveLoop(linkedList));
+        linkedList.printList();
+
+        linkedList = new SingleLinkedList<>();
+        linkedList.add(0);
+        System.out.println(detectAndRemoveLoop(linkedList));
+        linkedList.printList();
+
+        linkedList = new SingleLinkedList<>();
+        linkedList.add(0);
+        linkedList.getNode(0).next = linkedList.getNode(0);
+        System.out.println(detectAndRemoveLoop(linkedList));
+        linkedList.printList();
     }
 }