fix: update solutions to lc problem: No.0141 (doocs#2546)

No.0141.Linked List Cycle

Author: yanglbme

solution/0100-0199/0141.Linked List Cycle/README.md

@@ -64,7 +64,7 @@
 
 ### 方法一：哈希表
 
-遍历链表，并使用哈希表记录每个节点。当某个节点二次出现时，则表示存在环，直接返回 `true`。否则链表遍历结束，返回 `false`。
+我们可以遍历链表，用一个哈希表 $s$ 记录每个节点。当某个节点二次出现时，则表示存在环，直接返回 `true`。否则链表遍历结束，返回 `false`。
 
 时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是链表中的节点数。
 
@@ -78,6 +78,131 @@
 #         self.next = None
 
 
+class Solution:
+    def hasCycle(self, head: Optional[ListNode]) -> bool:
+        s = set()
+        while head:
+            if head in s:
+                return True
+            s.add(head)
+            head = head.next
+        return False
+```
+
+```java
+/**
+ * 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) {
+        Set<ListNode> s = new HashSet<>();
+        for (; head != null; head = head.next) {
+            if (!s.add(head)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+```
+
+```cpp
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    bool hasCycle(ListNode* head) {
+        unordered_set<ListNode*> s;
+        for (; head; head = head->next) {
+            if (s.contains(head)) {
+                return true;
+            }
+            s.insert(head);
+        }
+        return false;
+    }
+};
+```
+
+```go
+/**
+ * Definition for singly-linked list.
+ * type ListNode struct {
+ *     Val int
+ *     Next *ListNode
+ * }
+ */
+func hasCycle(head *ListNode) bool {
+	s := map[*ListNode]bool{}
+	for ; head != nil; head = head.Next {
+		if s[head] {
+			return true
+		}
+		s[head] = true
+	}
+	return false
+}
+```
+
+```ts
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     val: number
+ *     next: ListNode | null
+ *     constructor(val?: number, next?: ListNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.next = (next===undefined ? null : next)
+ *     }
+ * }
+ */
+
+function hasCycle(head: ListNode | null): boolean {
+    const s: Set<ListNode> = new Set();
+    for (; head; head = head.next) {
+        if (s.has(head)) {
+            return true;
+        }
+        s.add(head);
+    }
+    return false;
+}
+```
+
+<!-- tabs:end -->
+
+### 方法二：快慢指针
+
+我们定义快慢指针 $fast$ 和 $slow$，初始时均指向 $head$。
+
+快指针每次走两步，慢指针每次走一步，不断循环。当快慢指针相遇时，说明链表存在环。如果循环结束依然没有相遇，说明链表不存在环。
+
+时间复杂度 $O(n)$，其中 $n$ 是链表中的节点数。空间复杂度 $O(1)$。
+
+<!-- tabs:start -->
+
+```python
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+
 class Solution:
     def hasCycle(self, head: ListNode) -> bool:
         slow = fast = head
@@ -176,14 +301,14 @@ func hasCycle(head *ListNode) bool {
  */
 
 function hasCycle(head: ListNode | null): boolean {
-    const set = new Set<ListNode>();
-    let node = head;
-    while (node !== null) {
-        if (set.has(node)) {
+    let slow = head;
+    let fast = head;
+    while (fast !== null && fast.next !== null) {
+        slow = slow.next;
+        fast = fast.next.next;
+        if (slow === fast) {
             return true;
         }
-        set.add(node);
-        node = node.next;
     }
     return false;
 }
@@ -246,43 +371,4 @@ public class Solution {
 
 <!-- tabs:end -->
 
-### 方法二：快慢指针
-
-我们定义快慢指针 $fast$ 和 $slow$，初始时均指向 $head$。
-
-快指针每次走两步，慢指针每次走一步，不断循环。当快慢指针相遇时，说明链表存在环。如果循环结束依然没有相遇，说明链表不存在环。
-
-时间复杂度 $O(n)$，其中 $n$ 是链表中的节点数。空间复杂度 $O(1)$。
-
-<!-- tabs:start -->
-
-```ts
-/**
- * Definition for singly-linked list.
- * class ListNode {
- *     val: number
- *     next: ListNode | null
- *     constructor(val?: number, next?: ListNode | null) {
- *         this.val = (val===undefined ? 0 : val)
- *         this.next = (next===undefined ? null : next)
- *     }
- * }
- */
-
-function hasCycle(head: ListNode | null): boolean {
-    let slow = head;
-    let fast = head;
-    while (fast !== null && fast.next !== null) {
-        slow = slow.next;
-        fast = fast.next.next;
-        if (slow === fast) {
-            return true;
-        }
-    }
-    return false;
-}
-```
-
-<!-- tabs:end -->
-
 <!-- end -->