https://github.com/emahtab/linked-list-cycle
Linked List Cycle
https://github.com/emahtab/linked-list-cycle
detect-cycle hashset leetcode linked-list problem-solving
Last synced: 5 months ago
JSON representation
Linked List Cycle
- Host: GitHub
- URL: https://github.com/emahtab/linked-list-cycle
- Owner: eMahtab
- Created: 2020-02-09T16:53:55.000Z (almost 6 years ago)
- Default Branch: master
- Last Pushed: 2021-08-15T14:07:55.000Z (over 4 years ago)
- Last Synced: 2025-06-06T06:41:05.635Z (5 months ago)
- Topics: detect-cycle, hashset, leetcode, linked-list, problem-solving
- Size: 6.84 KB
- Stars: 1
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# Linked List Cycle
## https://leetcode.com/problems/linked-list-cycle
Given a linked list, determine if it has a cycle in it.
To represent a cycle in the given linked list, we use an integer pos which represents the position (0-indexed) in the linked list where tail connects to. If pos is -1, then there is no cycle in the linked list.
```
Example 1:
Input: head = [3,2,0,-4], pos = 1
Output: true
Explanation: There is a cycle in the linked list, where tail connects to the second node.
Example 2:
Input: head = [1,2], pos = 0
Output: true
Explanation: There is a cycle in the linked list, where tail connects to the first node.
Example 3:
Input: head = [1], pos = -1
Output: false
Explanation: There is no cycle in the linked list.
```
**Follow up:**
Can you solve it using O(1) (i.e. constant) memory?
## Implementation 1 : Time : O(n), Space : O(n)
```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) {
if(head == null)
return false;
Set set = new HashSet<>();
ListNode current = head;
while(current != null) {
if(set.contains(current))
return true;
set.add(current);
current = current.next;
}
return false;
}
}
```
## Implementation 2: (Fast & Slow will eventually meet :handshake: )
```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) {
// If there is no node or just one node in the linked list
if (head == null || head.next == null) {
return false;
}
ListNode slow = head;
ListNode fast = head.next;
while (slow != fast) {
if (fast == null || fast.next == null) {
return false;
}
slow = slow.next;
fast = fast.next.next;
}
return true;
}
}
```
## Implementation 2: Just little different (Fast & Slow will eventually meet :handshake: )
```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) {
if(head == null)
return false;
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;
}
}
```
# References :
1. https://leetcode.com/articles/linked-list-cycle
2. https://www.youtube.com/watch?v=6OrZ4wAy4uE