112 lines
2.4 KiB
Markdown
112 lines
2.4 KiB
Markdown
# Leetcode Linked-List-Cycle
|
||
|
||
#### 2022-06-14 21:54
|
||
|
||
---
|
||
|
||
##### Algorithms:
|
||
|
||
#algorithm #Floyd_s_cycle_finding_algorithm
|
||
|
||
##### Data structures:
|
||
|
||
#DS #linked_list
|
||
|
||
##### Difficulty:
|
||
|
||
#leetcode #coding_problem #difficulty-easy
|
||
|
||
##### Related topics:
|
||
|
||
##### Links:
|
||
|
||
- [Link to problem](https://leetcode.com/problems/linked-list-cycle/)
|
||
|
||
---
|
||
|
||
### Problem
|
||
|
||
Given `head`, the head of a linked list, determine if the linked list has a cycle in it.
|
||
|
||
There is a cycle in a linked list if there is some node in the list that can be reached again by continuously following the `next` pointer. Internally, `pos` is used to denote the index of the node that tail's `next` pointer is connected to. **Note that `pos` is not passed as a parameter**.
|
||
|
||
Return `true` _if there is a cycle in the linked list_. Otherwise, return `false`.
|
||
**Follow up:** Can you solve it using `O(1)` (i.e. constant) memory?
|
||
|
||
#### Examples
|
||
|
||
**Example 1:**
|
||
|
||
|
||
|
||
```markdown
|
||
**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:**
|
||
|
||
|
||
|
||
```markdown
|
||
**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:**
|
||
|
||
|
||
|
||
```markdown
|
||
**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, 104]`.
|
||
- `-105 <= Node.val <= 105`
|
||
- `pos` is `-1` or a **valid index** in the linked-list.
|
||
|
||
### Thoughts
|
||
|
||
> [!summary] > **Algorithm:**
|
||
> This is a #Floyd_s_cycle_finding_algorithm.
|
||
> This is pretty straightforward, visit for more info
|
||
|
||
### Solution
|
||
|
||
O(n)
|
||
|
||
```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) {
|
||
ListNode *slow = head;
|
||
ListNode *fast = head;
|
||
|
||
while (fast != NULL && fast->next != NULL) {
|
||
slow = slow->next;
|
||
fast = fast->next->next;
|
||
|
||
if (slow == fast) {
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
};
|
||
|
||
```
|