refactor(data-structures, linked-lists): split circular linked list

Author: BrianLusina

datastructures/linked_lists/circular/__init__.py

@@ -206,34 +206,54 @@ def split_list(self) -> Optional[Tuple[CircularNode, Optional[CircularNode]]]:
         Returns:
             Tuple: tuple with two circular linked lists
         """
-        size = len(self)
-
-        if size == 0:
+        # If there is no head node, there is nothing more to do here
+        if not self.head:
             return None
-        if size == 1:
-            return self.head, None
 
-        mid = size // 2
-        count = 0
+        # Get the middle of the linked list
+        middle_node = self.middle_node()
 
-        previous: Optional[CircularNode] = None
-        current = self.head
+        # Set the head node to head_one and head_two will be the head node of the second linked list
+        head_one = self.head
+        head_two = middle_node.next
+        # Set the middle node's next pointer to cycle back to the head_one node
+        middle_node.next = head_one
 
-        while current and count < mid:
-            count += 1
-            previous = current
+        # Assign a pointer to the second head node and move it along the linked list as long as it's next pointer is not
+        # equal to the head node
+        current = head_two
+        while current.next is not self.head:
             current = current.next
 
-        previous.next = self.head
+        # Now since we are at the tail of the linked list, we assign the next pointer to point to the second head node
+        current.next = head_two
 
-        second_list = CircularLinkedList()
-        while current.next != self.head:
-            second_list.append(current.data)
-            current = current.next
+        # Now we have split the linked list into two halves.
+        return head_one, head_two
+
+    def middle_node(self) -> Optional[CircularNode]:
+        """
+        Traverse the linked list to find the middle node. For a circular linked list, the tail node points back to the
+        head node, to prevent this from continuously looping, we have to break the cycle once the tail node's next pointer
+        points back to the head node
+        Time Complexity: O(n) where n is the number of nodes in the linked list
+        Space Complexity: O(1) as constant extra space is needed
+        Return:
+            CircularNode: middle node of linked list
+        """
+        if not self.head:
+            return None
+
+        fast_pointer, slow_pointer = self.head, self.head
 
-        second_list.append(current.data)
+        while (
+            fast_pointer.next is not self.head
+            and fast_pointer.next.next is not self.head
+        ):
+            slow_pointer = slow_pointer.next
+            fast_pointer = fast_pointer.next.next
 
-        return self.head, second_list
+        return slow_pointer
 
     def is_palindrome(self) -> bool:
         pass

datastructures/linked_lists/circular/test_circular_linked_list.py

@@ -55,24 +55,5 @@ def test_1(self):
         self.assertEqual(expected, list(circular_linked_list))
 
 
-class CircularLinkedListSplitListTestCase(unittest.TestCase):
-    def test_1(self):
-        """should split a linked list [1,2,3,4,5,6] to become ([1,2,3],[4,5,6])"""
-        data = [1, 2, 3, 4, 5, 6]
-        expected = ([1, 2, 3], [4, 5, 6])
-        circular_linked_list = CircularLinkedList()
-
-        for d in data:
-            circular_linked_list.append(d)
-
-        result = circular_linked_list.split_list()
-        self.assertIsNotNone(result)
-
-        first_list_head, second_list_head = result
-
-        self.assertEqual(expected[0], list(first_list_head))
-        self.assertEqual(expected[1], list(second_list_head))
-
-
 if __name__ == "__main__":
     unittest.main()

datastructures/linked_lists/circular/test_circular_linked_list_split.py

@@ -0,0 +1,51 @@
+import unittest
+from typing import List, Tuple
+from parameterized import parameterized
+from datastructures.linked_lists.circular import CircularLinkedList
+from datastructures.linked_lists.circular.node import CircularNode
+
+
+CIRCULAR_LINKED_LIST_SPLIT_LIST_TEST_CASES = [
+    ([1, 2, 3, 4, 5, 6], ([1, 2, 3], [4, 5, 6])),
+    ([], ([], [])),
+    ([1, 5, 7], ([1, 5], [7])),
+    ([2, 6, 1, 5], ([2, 6], [1, 5])),
+    ([3, 1, 4, 2, 5], ([3, 1, 4], [2, 5])),
+    ([8, 10, 12, 14, 16, 18], ([8, 10, 12], [14, 16, 18])),
+    ([9, 10], ([9], [10])),
+]
+
+
+class CircularLinkedListSplitListTestCase(unittest.TestCase):
+    def assert_data(self, head: CircularNode, expected: List[int]):
+        current = head
+        actual = []
+        while current:
+            actual.append(current.data)
+            if current.next is head:
+                break
+            current = current.next
+
+        self.assertListEqual(expected, actual)
+
+    @parameterized.expand(CIRCULAR_LINKED_LIST_SPLIT_LIST_TEST_CASES)
+    def test_split_list(self, data: List[int], expected: Tuple[List[int], List[int]]):
+        circular_linked_list = CircularLinkedList()
+        if not data:
+            result = circular_linked_list.split_list()
+            self.assertIsNone(result)
+            return
+
+        for d in data:
+            circular_linked_list.append(d)
+
+        result = circular_linked_list.split_list()
+        self.assertIsNotNone(result)
+
+        first_list_head, second_list_head = result
+        self.assert_data(first_list_head, expected[0])
+        self.assert_data(second_list_head, expected[1])
+
+
+if __name__ == "__main__":
+    unittest.main()