Added tasks 141-143.

Author: javadev

src/main/java/g0101_0200/s0141_linked_list_cycle/Solution.java

@@ -0,0 +1,32 @@
+package g0101_0200.s0141_linked_list_cycle;
+
+import com_github_leetcode.ListNode;
+
+/*
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) {
+ *         val = x;
+ *         next = null;
+ *     }
+ * }
+ */
+public class Solution {
+    public boolean hasCycle(ListNode head) {
+        if (head == null) {
+            return false;
+        }
+        ListNode fast = head.next;
+        ListNode slow = head;
+        while (fast != null && fast.next != null) {
+            if (fast == slow) {
+                return true;
+            }
+            fast = fast.next.next;
+            slow = slow.next;
+        }
+        return false;
+    }
+}

src/main/java/g0101_0200/s0142_linked_list_cycle_ii/Solution.java

@@ -0,0 +1,41 @@
+package g0101_0200.s0142_linked_list_cycle_ii;
+
+import com_github_leetcode.ListNode;
+
+/*
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) {
+ *         val = x;
+ *         next = null;
+ *     }
+ * }
+ */
+public class Solution {
+    public ListNode detectCycle(ListNode head) {
+        if (head == null || head.next == null) {
+            return null;
+        }
+        ListNode slow = head;
+        ListNode fast = head;
+        while (fast != null && fast.next != null) {
+            fast = fast.next.next;
+            slow = slow.next;
+            // intersected inside the loop.
+            if (slow == fast) {
+                break;
+            }
+        }
+        if (fast == null || fast.next == null) {
+            return null;
+        }
+        slow = head;
+        while (slow != fast) {
+            slow = slow.next;
+            fast = fast.next;
+        }
+        return slow;
+    }
+}

src/main/java/g0101_0200/s0143_reorder_list/Solution.java

@@ -0,0 +1,45 @@
+package g0101_0200.s0143_reorder_list;
+
+import com_github_leetcode.ListNode;
+
+/*
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) {
+ *         val = x;
+ *         next = null;
+ *     }
+ * }
+ */
+public class Solution {
+    ListNode forward;
+
+    public void reorderList(ListNode head) {
+        forward = head;
+        dfs(head);
+    }
+
+    private void dfs(ListNode node) {
+        if (node != null) {
+            dfs(node.next);
+            if (forward != null) {
+                ListNode next = forward.next;
+                // even case: forward.next coincide with node
+                if (next == node) {
+                    node.next = null;
+                } else {
+                    node.next = next;
+                }
+                forward.next = node;
+                forward = node.next;
+            }
+            // odd case: forward coincide with node
+            if (forward == node) {
+                forward.next = null;
+                forward = forward.next;
+            }
+        }
+    }
+}

src/test/java/g0101_0200/s0141_linked_list_cycle/SolutionTest.java

@@ -0,0 +1,19 @@
+package g0101_0200.s0141_linked_list_cycle;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com_github_leetcode.ListNode;
+import org.junit.Test;
+
+public class SolutionTest {
+    @Test
+    public void hasCycle() {
+        ListNode listNode1 = new ListNode(3);
+        listNode1.next = new ListNode(2);
+        listNode1.next.next = new ListNode(0);
+        listNode1.next.next.next = new ListNode(-4);
+        listNode1.next.next.next.next = listNode1.next;
+        assertThat(new Solution().hasCycle(listNode1), equalTo(true));
+    }
+}

src/test/java/g0101_0200/s0142_linked_list_cycle_ii/SolutionTest.java

@@ -0,0 +1,19 @@
+package g0101_0200.s0142_linked_list_cycle_ii;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com_github_leetcode.ListNode;
+import org.junit.Test;
+
+public class SolutionTest {
+    @Test
+    public void detectCycle() {
+        ListNode listNode1 = new ListNode(3);
+        listNode1.next = new ListNode(2);
+        listNode1.next.next = new ListNode(0);
+        listNode1.next.next.next = new ListNode(-4);
+        listNode1.next.next.next.next = listNode1.next;
+        assertThat(new Solution().detectCycle(listNode1), equalTo(listNode1.next));
+    }
+}

src/test/java/g0101_0200/s0143_reorder_list/SolutionTest.java

@@ -0,0 +1,19 @@
+package g0101_0200.s0143_reorder_list;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com_github_leetcode.ListNode;
+import org.junit.Test;
+
+public class SolutionTest {
+    @Test
+    public void reorderList() {
+        ListNode listNode1 = new ListNode(1);
+        listNode1.next = new ListNode(2);
+        listNode1.next.next = new ListNode(3);
+        listNode1.next.next.next = new ListNode(4);
+        new Solution().reorderList(listNode1);
+        assertThat(listNode1.toString(), equalTo("1, 4, 2, 3"));
+    }
+}