feat: add python and java solutions to lcci question

添加《程序员面试金典》题解：面试题 02.08. 环路检测

Author: yanglbme

lcci/02.08.Linked List Cycle/README.md

@@ -12,14 +12,60 @@
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
 
+class Solution:
+    def detectCycle(self, head: ListNode) -> ListNode:
+        fast = slow = p = head
+        while fast and fast.next:
+            fast = fast.next.next
+            slow = slow.next
+            if fast == slow:
+                break
+        if fast is None or fast.next is None:
+            return None
+        while slow != p:
+            p = p.next
+            slow = slow.next
+        return p
 ```
 
 ### Java
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
-
+/**
+ * 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) {
+         ListNode fast = head, slow = head;
+         while (fast != null && fast.next != null) {
+             fast = fast.next.next;
+             slow = slow.next;
+             if (fast == slow) break;
+         }
+         if (fast == null || fast.next == null) return null;
+         ListNode p = head;
+         while (p != slow) {
+             p = p.next;
+             slow = slow.next;
+         }
+         return p;
+    }
+}
 ```
 
 ### ...

lcci/02.08.Linked List Cycle/README_EN.md

@@ -1,49 +1,119 @@
-# [02.08. Linked List Cycle](https://leetcode-cn.com/problems/linked-list-cycle-lcci)
-
-## Description
-<p>Given a circular linked list, implement an algorithm that returns the node at the beginning of the loop.</p>
-
-<p>Circular linked list: A (corrupt) linked list in which a node&#39;s next pointer points to an earlier node, so as to make a loop in the linked list.</p>
-
-<p><strong>Example 1: </strong></p>
-
-<pre>
-<strong>Input: </strong>head = [3,2,0,-4], pos = 1
-<strong>Output: </strong>tail connects to node index 1</pre>
-
-<p><strong>Example 2: </strong></p>
-
-<pre>
-<strong>Input: </strong>head = [1,2], pos = 0
-<strong>Output: </strong>tail connects to node index 0</pre>
-
-<p><strong>Example 3: </strong></p>
-
-<pre>
-<strong>Input: </strong>head = [1], pos = -1
-<strong>Output: </strong>no cycle</pre>
-
-<p><strong>Follow Up: </strong><br />
-Can you solve it without using additional space?</p>
-
-
-
-## Solutions
-
-
-### Python3
-
-```python
-
-```
-
-### Java
-
-```java
-
-```
-
-### ...
-```
-
-```
+# [02.08. Linked List Cycle](https://leetcode-cn.com/problems/linked-list-cycle-lcci)
+
+## Description
+<p>Given a circular linked list, implement an algorithm that returns the node at the beginning of the loop.</p>
+
+
+
+<p>Circular linked list: A (corrupt) linked list in which a node&#39;s next pointer points to an earlier node, so as to make a loop in the linked list.</p>
+
+
+
+<p><strong>Example 1: </strong></p>
+
+
+
+<pre>
+
+<strong>Input: </strong>head = [3,2,0,-4], pos = 1
+
+<strong>Output: </strong>tail connects to node index 1</pre>
+
+
+
+<p><strong>Example 2: </strong></p>
+
+
+
+<pre>
+
+<strong>Input: </strong>head = [1,2], pos = 0
+
+<strong>Output: </strong>tail connects to node index 0</pre>
+
+
+
+<p><strong>Example 3: </strong></p>
+
+
+
+<pre>
+
+<strong>Input: </strong>head = [1], pos = -1
+
+<strong>Output: </strong>no cycle</pre>
+
+
+
+<p><strong>Follow Up: </strong><br />
+
+Can you solve it without using additional space?</p>
+
+
+
+
+## Solutions
+
+
+### Python3
+
+```python
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution:
+    def detectCycle(self, head: ListNode) -> ListNode:
+        fast = slow = p = head
+        while fast and fast.next:
+            fast = fast.next.next
+            slow = slow.next
+            if fast == slow:
+                break
+        if fast is None or fast.next is None:
+            return None
+        while slow != p:
+            p = p.next
+            slow = slow.next
+        return p
+```
+
+### Java
+
+```java
+/**
+ * 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) {
+         ListNode fast = head, slow = head;
+         while (fast != null && fast.next != null) {
+             fast = fast.next.next;
+             slow = slow.next;
+             if (fast == slow) break;
+         }
+         if (fast == null || fast.next == null) return null;
+         ListNode p = head;
+         while (p != slow) {
+             p = p.next;
+             slow = slow.next;
+         }
+         return p;
+    }
+}
+```
+
+### ...
+```
+
+```

lcci/02.08.Linked List Cycle/Solution.java

@@ -0,0 +1,28 @@
+/**
+ * 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) {
+         ListNode fast = head, slow = head;
+         while (fast != null && fast.next != null) {
+             fast = fast.next.next;
+             slow = slow.next;
+             if (fast == slow) break;
+         }
+         if (fast == null || fast.next == null) return null;
+         ListNode p = head;
+         while (p != slow) {
+             p = p.next;
+             slow = slow.next;
+         }
+         return p;
+    }
+}

lcci/02.08.Linked List Cycle/Solution.py

@@ -0,0 +1,20 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution:
+    def detectCycle(self, head: ListNode) -> ListNode:
+        fast = slow = p = head
+        while fast and fast.next:
+            fast = fast.next.next
+            slow = slow.next
+            if fast == slow:
+                break
+        if fast is None or fast.next is None:
+            return None
+        while slow != p:
+            p = p.next
+            slow = slow.next
+        return p