refactor(data-structures, linked list): reorder linked list tests

Author: BrianLusina

datastructures/linked_lists/reorder_list/__init__.py

@@ -1,5 +1,5 @@
-from typing import Optional, List
-from ..singly_linked_list.node import SingleNode
+from typing import Optional
+from datastructures.linked_lists.singly_linked_list.node import SingleNode
 
 
 def reorder_list(head: Optional[SingleNode]) -> None:
@@ -9,32 +9,54 @@ def reorder_list(head: Optional[SingleNode]) -> None:
     if not head or not head.next:
         return
 
-    # first find the middle of the linked list
+    # First find the middle of the linked list
+    # Find the middle of the linked list using the two pointer approach, where we move the first
+    # pointer two nodes forward while moving the slow pointer one node forward. When the fast pointer reaches
+    # the end of the linked list, the slow pointer will be at the middle node
+
     slow = head
     fast = head.next
 
     while fast and fast.next:
         slow = slow.next
         fast = fast.next.next
 
-    # second half of the list
+    # second half of the linked list will be the next node of the slow pointer
     second = slow.next
+    # cut the connection between the second half and the first half
     slow.next = None
+    # this will keep track of the previous node in the second half of the linked list
     previous = None
 
     # reversing the second portion of the list
     while second:
+        # temporarily store the next node
         temp = second.next
+        # set the next pointer to the previous node
         second.next = previous
+        # move the previous node forward
         previous = second
+        # move the second half head forward
         second = temp
 
-    # merge the 2 halves
+    # The second half of the linked list has been reversed.
+    # Now we merge and weave the first half and the second
+
+    # first_half_head will point to the head node of the first half
     first = head
+    # Set the second_half_head to previous as previous will now be the head of the second half of the linked list
     second = previous
 
     while second:
+        # save the next pointers of both nodes to not lose track of them
         temp1, temp2 = first.next, second.next
+
+        # Assign the first half head node's next to the second half head node
+        # And assign the second half next node to the first half next node
+        # This is where the merging and weaving happens
+
         first.next = second
         second.next = temp1
+
+        # Move the pointers forward for further iterations
         first, second = temp1, temp2

…uctures/linked_list/test_reorder_list.py …_lists/reorder_list/test_reorder_list.pytests/datastructures/linked_list/test_reorder_list.py renamed to datastructures/linked_lists/reorder_list/test_reorder_list.py tests/datastructures/linked_list/test_reorder_list.py renamed to datastructures/linked_lists/reorder_list/test_reorder_list.py

@@ -4,24 +4,26 @@
 
 
 class ReorderListTestCase(unittest.TestCase):
-    @unittest.skip(
-        "Skipping due to a missing dunder method on __repr__ & __eq__ on the SingleNode class"
-    )
     def test_1_2_3_4_returns_1_4_2_3(self):
         """Should return 1 -> 4 -> 2 -> 3 from 1 -> 2 -> 3 -> 4"""
         head = SingleNode(
             1, next_=SingleNode(2, next_=SingleNode(3, next_=SingleNode(4)))
         )
-        expected = SingleNode(
+        expected_head = SingleNode(
             1, next_=SingleNode(4, next_=SingleNode(2, next_=SingleNode(3)))
         )
+        expected = [1, 4, 2, 3]
         reorder_list(head)
-        self.assertEqual(expected, head)
-        self.assertEqual(expected, head)
 
-    @unittest.skip(
-        "Skipping due to a missing dunder method on __repr__ & __eq__ on the SingleNode class"
-    )
+        actual = []
+        current = head
+        while current:
+            actual.append(current.data)
+            current = current.next
+
+        self.assertEqual(expected_head, head)
+        self.assertEqual(expected, actual)
+
     def test_1_2_3_4_5_returns_1_5_2_4_3(self):
         """Should return 1 -> 5 -> 2 -> 4 -> 3 from 1 -> 2 -> 3 -> 4 -> 5"""
         head = SingleNode(
@@ -30,14 +32,24 @@ def test_1_2_3_4_5_returns_1_5_2_4_3(self):
                 2, next_=SingleNode(3, next_=SingleNode(4, next_=SingleNode(5)))
             ),
         )
-        expected = SingleNode(
+        expected_head = SingleNode(
             1,
             next_=SingleNode(
                 5, next_=SingleNode(2, next_=SingleNode(4, next_=SingleNode(3)))
             ),
         )
+        expected = [1, 5, 2, 4, 3]
+
         reorder_list(head)
-        self.assertEqual(expected, head)
+
+        actual = []
+        current = head
+        while current:
+            actual.append(current.data)
+            current = current.next
+
+        self.assertEqual(expected_head, head)
+        self.assertEqual(expected, actual)
 
 
 if __name__ == "__main__":

datastructures/linked_lists/singly_linked_list/single_linked_list.py

@@ -1015,7 +1015,7 @@ def reorder_list(self) -> Optional[SingleNode]:
             return None
 
         # first split the linked list into two halves. To do this without knowing the length of the linked list beforehand
-        # we must first find the middle node. This uses the slow & fast pointer approach
+        # we must first find the middle node. This uses the slow and fast pointer approach
         middle_node = self.middle_node()
 
         # Store the second half head node

datastructures/linked_lists/singly_linked_list/single_linked_list_utils.py

@@ -6,7 +6,7 @@ def merge_and_weave(
     first_half_head: SingleNode, second_half_head: SingleNode
 ) -> Optional[SingleNode]:
     """
-    Merges and weaves the first half and the reversed second half of the linked list in place.
+    Merges and weaves the first half and the second half of a linked list in place.
     Args:
         first_half_head: head node of the first half of the linked list
         second_half_head: head node of the reversed second half of the linked list