mirror of
https://github.com/prdlk/leetcode.git
synced 2026-11-02 13:12:44 +00:00
84 lines
2.4 KiB
Plaintext
84 lines
2.4 KiB
Plaintext
---
|
|
title: '141. Linked List Cycle'
|
|
description: Given head, the head of a linked list, determine if the linked list has a cycle in it
|
|
icon: dot
|
|
topics:
|
|
- { name: "Hash Table", slug: "hash-table" }
|
|
- { name: "Linked List", slug: "linked-list" }
|
|
- { name: "Two Pointers", slug: "two-pointers" }
|
|
- { name: "Floyd's Cycle Finding Algorithm", slug: "floyds-cycle-finding-algorithm" }
|
|
video: "gBTe7lFR3vc"
|
|
issue: "https://github.com/prdlk/leetcode/issues/79"
|
|
companies:
|
|
- { name: "Meta", period: "Thirty Days", frequency: 53.8 }
|
|
- { name: "Amazon", period: "Thirty Days", frequency: 39.1 }
|
|
- { name: "Google", period: "Thirty Days", frequency: 29 }
|
|
- { name: "Nvidia", period: "Three Months", frequency: 87.7 }
|
|
- { name: "Microsoft", period: "Three Months", frequency: 42.1 }
|
|
- { name: "Bloomberg", period: "Six Months", frequency: 25.5 }
|
|
sidebar:
|
|
label: 'Linked List Cycle'
|
|
badge: 'Easy'
|
|
---
|
|
|
|
::::warning
|
|
Can you solve it using O(1) (i.e. constant) memory?
|
|
::::
|
|
|
|
### Example 1:
|
|
- Input: `head = [3,2,0,-4], pos = 1`
|
|
- Output: `true`
|
|
- Explanation: There is a cycle in the linked list, where the tail connects to the 1st node (0-indexed).
|
|
|
|
### Example 2:
|
|
- Input: `head = [1,2], pos = 0`
|
|
- Output: `true`
|
|
- Explanation: There is a cycle in the linked list, where the tail connects to the 0th node.
|
|
|
|
### Example 3:
|
|
- Input: `head = [1], pos = -1`
|
|
- Output: `false`
|
|
- Explanation: There is no cycle in the linked list.
|
|
|
|
### Constraints:
|
|
|
|
- The number of the nodes in the list is in the range [0, 10^4].
|
|
- `-10^5 <= Node.val <= 10^5`
|
|
- pos is -1 or a valid index in the linked-list.
|
|
|
|
## Approach
|
|
|
|
```mermaid
|
|
flowchart TD
|
|
S(["hasCycle(head)"]) --> I["fast = slow = head"]
|
|
I --> W{"fast and fast.next?"}
|
|
W -- no --> E(["return False — ran off the end, no cycle"])
|
|
W -- yes --> A["fast = fast.next.next — two steps"]
|
|
A --> B["slow = slow.next — one step"]
|
|
B --> Q{"fast is slow?"}
|
|
Q -- yes --> R(["return True — the gap closed, so it loops"])
|
|
Q -- no --> W
|
|
```
|
|
|
|
## Solution
|
|
|
|
```py
|
|
# Definition for singly-linked list.
|
|
# class ListNode:
|
|
# def __init__(self, x):
|
|
# self.val = x
|
|
# self.next = None
|
|
|
|
|
|
class Solution:
|
|
def hasCycle(self, head: Optional[ListNode]) -> bool:
|
|
fast = slow = head
|
|
|
|
while fast and fast.next:
|
|
fast = fast.next.next
|
|
slow = slow.next
|
|
if fast is slow:
|
|
return True
|
|
return False
|
|
```
|