@@ -16,6 +16,7 @@ My solutions to LeetCode problems in Kotlin.
 | [54](https://leetcode.com/problems/spiral-matrix/) | [Spiral Matrix](src/main/kotlin/com/schmoczer/leetcode/_0054/SpiralMatrix.kt) | Medium |
 | [73](https://leetcode.com/problems/set-matrix-zeroes/) | [Set Matrix Zeroes](src/main/kotlin/com/schmoczer/leetcode/_0073/SetMatrixZeroes.kt) | Medium |
 | [125](https://leetcode.com/problems/valid-palindrome/) | [Valid Palindrome](src/main/kotlin/com/schmoczer/leetcode/_0125/ValidPalindrome.kt) | Easy |
+| [141](https://leetcode.com/problems/linked-list-cycle/) | [Linked List Cycle](src/main/kotlin/com/schmoczer/leetcode/_0141/LinkedListCycle.kt) | Easy |
 | [151](https://leetcode.com/problems/reverse-words-in-a-string/) | [Reverse Words in a String](src/main/kotlin/com/schmoczer/leetcode/_0151/ReverseWordsInString.kt) | Medium |
 | [186](https://leetcode.com/problems/reverse-words-in-a-string-ii/) | [Reverse Words in a String II](src/main/kotlin/com/schmoczer/leetcode/_0186/ReverseWordsInStringInPlace.kt) | Medium |
 | [206](https://leetcode.com/problems/reverse-linked-list/) | [Reverse Linked List](src/main/kotlin/com/schmoczer/leetcode/_0206/ReverseLinkedList.kt) | Easy |

@@ -0,0 +1,43 @@
+package com.schmoczer.leetcode._0141
+
+class LinkedListCycle {
+// Approach 1
+fun hasCycle1(head: ListNode?): Boolean {
+val visitedNodes = mutableSetOf<ListNode>()
+var current = head
+while (current?.next != null) {
+if (visitedNodes.add(current).not()) {
+return true
+}
+current = current.next
+}
+return false
+}
+
+// Approach 2: slow and fast pointer
+fun hasCycle(head: ListNode?): Boolean {
+if (head?.next == null) {
+return false
+}
+var slow: ListNode? = head
+var fast: ListNode? = slow?.next
+while (fast?.next != null) {
+fast = fast.next?.next
+if (fast === slow) {
+return true
+}
+slow = slow?.next
+}
+return false
+}
+}
+
+/**
+* Example:
+* var li = ListNode(5)
+* var v = li.`val`
+* Definition for singly-linked list.
+*/
+class ListNode(var `val`: Int) {
+var next: ListNode? = null
+}

@@ -0,0 +1,11 @@
+# Linked List Cycle
+
+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.
+
+Constraints:
+
+- The number of the nodes in the list is in the range `[0, 10^4]`.
+- `-10^5 <= Node.val <= 10^5`

@@ -0,0 +1,42 @@
+package com.schmoczer.leetcode._0141
+
+import org.junit.jupiter.api.BeforeEach
+import kotlin.test.Test
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+class LinkedListCycleTest {
+private lateinit var sut: LinkedListCycle
+
+@BeforeEach
+fun setUp() {
+sut = LinkedListCycle()
+}
+
+@Test
+fun `tail connecting to 1st node is a cycle`() {
+val input = ListNode(3)
+input.next = ListNode(2)
+input.next?.next = ListNode(0)
+input.next?.next?.next = ListNode(4)
+input.next?.next?.next?.next = input.next
+
+assertTrue(sut.hasCycle(input))
+}
+
+@Test
+fun `tail connecting to head node is a cycle`() {
+val input = ListNode(1)
+input.next = ListNode(2)
+input.next?.next = input
+
+assertTrue(sut.hasCycle(input))
+}
+
+@Test
+fun `only one node with empty next is not a cycle`() {
+val input = ListNode(1)
+
+assertFalse(sut.hasCycle(input))
+}
+}