[Feature] Added Linked List cycle detection and cycle start detection.

Author: exterkamp

README.md

@@ -38,6 +38,9 @@ $ coverage report -m
 ### Data Structures
 * [LRU Cache](structures/lru_cache.py)
 * [Naïve Tree](structures/naive_tree.py)
+  * [In-Order Traversal](structures/naive_tree.py)
+  * [Pre-Order Traversal](structures/naive_tree.py)
+  * [Post-Order Traversal](structures/naive_tree.py)
 * [Binary Search Tree](structures/binary_search_tree.py)
 * [Hash Map](structures/hash_map.py)
   * [DJB2 Hash Function](structures/hash_map.py)
@@ -46,6 +49,9 @@ $ coverage report -m
 * [Heap](structures/heap.py)
 * [Trie](structures/trie.py)
 * [Priority Queue](structures/priority_queue.py)
+* [Linked List](structures/linked_list.py)
+  * [Contains Cycles](structures/linked_list.py)
+  * [Find Start of Cycle](structures/linked_list.py)
 
 ### Algorithms
 

structures/linked_list.py

@@ -0,0 +1,46 @@
+class ListNode():
+
+    def __init__(self, val, next=None):
+        self.val = val
+        self.next = next
+
+    def contains_cycle(self):
+        # the list is only 1 node long, which cannot contain a cycle
+        if not self.next:
+            return False
+        slow_pointer = self.next        
+        fast_pointer = self.next.next
+
+        while slow_pointer is not fast_pointer:
+            if slow_pointer:
+                slow_pointer = slow_pointer.next
+            if fast_pointer and fast_pointer.next:
+                fast_pointer = fast_pointer.next.next
+        if slow_pointer is None:
+            return False
+        else:
+            return True
+    
+    def get_beginning_of_cycle_if_exists(self):
+        # the list is only 1 node long, which cannot contain a cycle
+        if not self.next:
+            return None
+        slow_pointer = self.next
+        fast_pointer = self.next.next
+
+        while slow_pointer is not fast_pointer:
+            if slow_pointer:
+                slow_pointer = slow_pointer.next
+            if fast_pointer and fast_pointer.next:
+                fast_pointer = fast_pointer.next.next
+        if slow_pointer is None:
+            return None
+        # reset slow pointer
+        slow_pointer = self
+        # move the pointers again at same speed, will meet at start
+        while slow_pointer is not fast_pointer:
+            print(slow_pointer.val, fast_pointer.val)
+            slow_pointer = slow_pointer.next
+            fast_pointer = fast_pointer.next
+        
+        return slow_pointer

tests/test_linked_list.py

@@ -0,0 +1,56 @@
+import unittest
+from structures.linked_list import ListNode
+
+class TestLinkedList(unittest.TestCase):
+
+    def test_ll_contains_cycle(self):
+        head = ListNode(3)
+        head.next = ListNode(4)
+        head.next.next = ListNode(5)
+        cycle_start = ListNode(6)
+        head.next.next.next = cycle_start
+        cycle_start.next = ListNode(7)
+        cycle_start.next.next = ListNode(8)
+        cycle_start.next.next.next = cycle_start
+
+        self.assertTrue(head.contains_cycle())
+
+    def test_ll_no_cycle(self):
+        head = ListNode(3)
+        head.next = ListNode(4)
+        head.next.next = ListNode(5)
+        cycle_start = ListNode(6)
+        head.next.next.next = cycle_start
+        cycle_start.next = ListNode(7)
+        cycle_start.next.next = ListNode(8)
+
+        self.assertFalse(head.contains_cycle())
+    
+    def test_ll_cycle_on_single_node(self):
+        self.assertFalse(ListNode(1).contains_cycle())
+
+    def test_ll_get_cycle_start(self):
+        head = ListNode(3)
+        head.next = ListNode(4)
+        head.next.next = ListNode(5)
+        cycle_start = ListNode(6)
+        head.next.next.next = cycle_start
+        cycle_start.next = ListNode(7)
+        cycle_start.next.next = ListNode(8)
+        cycle_start.next.next.next = cycle_start
+
+        self.assertEqual(cycle_start, head.get_beginning_of_cycle_if_exists())
+
+    def test_ll_get_cycle_start_no_cycle(self):
+        head = ListNode(3)
+        head.next = ListNode(4)
+        head.next.next = ListNode(5)
+        cycle_start = ListNode(6)
+        head.next.next.next = cycle_start
+        cycle_start.next = ListNode(7)
+        cycle_start.next.next = ListNode(8)
+
+        self.assertEqual(None, head.get_beginning_of_cycle_if_exists())
+    
+    def test_ll_get_cycle_start_on_single_node(self):
+        self.assertEqual(None, ListNode(1).get_beginning_of_cycle_if_exists())