feat(data structures, linked list): additional algorithm to reverse_between

Author: BrianLusina

datastructures/linked_lists/singly_linked_list/single_linked_list.py

@@ -430,6 +430,67 @@ def reverse_between(self, left: int, right: int) -> Optional[SingleNode]:
         tail_pointer.next = current_pointer
         return self.head
 
+    def reverse_between_with_dummy(self, left: int, right: int) -> Optional[SingleNode]:
+        """
+        Reverse linked list between left & right node positions using a dummy node
+
+        Algorithm steps:
+        - We initialize a dummy node, which will be helpful in scenarios where the reversal of the sublist starts from
+        the head of the list.
+        - We set the next node of dummy to point to the head of the list.
+        - We initialize a pointer, prev, to the dummy node. This pointer will help us reconnect the sublist to the
+        entire list after it has been reversed.
+        - We use a loop to traverse the list with the prev pointer and until it reaches the node immediately before the
+        sublist to be reversed.
+        - We initialize a curr pointer, which points to the node next to prev.
+        - Another loop is used to reverse the sublist. This loop iterates right - left times, which is the number of
+        nodes in the sublist minus one:
+            - We set next_node to curr.next, representing the node to be moved to the front of the reversed sublist.
+            - We update curr.next to next_node.next, effectively removing next_node from its current position in the
+            sublist.
+            - We set next_node.next to prev.next, inserting next_node at the beginning of the reversed sublist.
+            - We update prev.next to next_node, adjusting the pointer to next_node for the next iteration.
+
+        - Finally, we return dummy.next, which is the head of the modified linked list.
+
+        Args:
+            left (int): the starting position
+            right (int): the end position
+
+        Returns:
+            Optional[SingleNode]: the head of the reversed linked list
+        """
+        if left > right:
+            raise ValueError(f"left {left} cannot be greater than right {right}")
+
+        if self.head is None or self.head.next is None:
+            return self.head
+
+        if right > len(self):
+            raise ValueError(
+                f"right {right} cannot be greater than the length of the linked list {len(self)}"
+            )
+
+        if left == right:
+            return self.head
+
+        dummy = SingleNode(0)
+        dummy.next = self.head
+        prev = dummy
+
+        for _ in range(left - 1):
+            prev = prev.next
+
+        curr = prev.next
+
+        for _ in range(right - left):
+            next_node = curr.next
+            curr.next = next_node.next
+            next_node.next = prev.next
+            prev.next = next_node
+
+        return dummy.next
+
     def unshift(self, node_: SingleNode) -> SingleNode:
         if self.head:
             return node_

datastructures/linked_lists/singly_linked_list/test_singly_linked_revese.py

@@ -70,6 +70,55 @@ def test_reverse_between(
         # perform assertion
         self.assertEqual(expected, actual_list)
 
+    @parameterized.expand(
+        [
+            ([1, 2, 3, 4, 5, 4, 3, 2, 1], 1, 9, [1, 2, 3, 4, 5, 4, 3, 2, 1]),
+            ([1, 2, 3, 4, 5], 2, 4, [1, 4, 3, 2, 5]),
+            ([1, 2, 3, 4, 5], 1, 5, [5, 4, 3, 2, 1]),
+            (
+                [103, 7, 10, -9, 105, 67, 31, 63],
+                1,
+                8,
+                [63, 31, 67, 105, -9, 10, 7, 103],
+            ),
+            (
+                [103, 7, 10, -9, 105, 67, 31, 63],
+                1,
+                8,
+                [63, 31, 67, 105, -9, 10, 7, 103],
+            ),
+            ([-499, 399, -299, 199, -99, 9], 3, 5, [-499, 399, -99, 199, -299, 9]),
+            ([7, -9, 2, -10, 1, -8, 6], 2, 5, [7, 1, -10, 2, -9, -8, 6]),
+            ([6, 8, 7], 1, 2, [8, 6, 7]),
+            ([9, 0, 8, 2], 2, 4, [9, 2, 8, 0]),
+            ([7, 4, 6, 1, 5, 8], 2, 5, [7, 5, 1, 6, 4, 8]),
+            ([3, 7, 12, 2, 5, 1], 3, 6, [3, 7, 1, 5, 2, 12]),
+            ([3, 6, 7, 4, 2], 2, 4, [3, 4, 7, 6, 2]),
+        ]
+    )
+    def test_reverse_between_with_dummy(
+        self, data: List[int], left: int, right: int, expected: List[int]
+    ):
+        """should reverse linked list between left and right arguments"""
+        linked_list = SinglyLinkedList()
+        # add the data to the linked list
+        for d in data:
+            linked_list.append(d)
+
+        # perform reversal
+        actual = linked_list.reverse_between_with_dummy(left, right)
+
+        # since the head node is returned, we want the values of the linked list and not just the head node
+        # to check that the actual reversal worked
+        actual_list: List[int] = []
+        curr = actual
+        while curr:
+            actual_list.append(curr.data)
+            curr = curr.next
+
+        # perform assertion
+        self.assertEqual(expected, actual_list)
+
 
 if __name__ == "__main__":
     unittest.main()