feat(datastructures, linked-lists): reorder list

Author: BrianLusina

datastructures/linked_lists/__init__.py

@@ -715,3 +715,36 @@ def pairs_with_sum(self, target: T) -> List[Tuple[Node, Node]]:
             List: list of pairs
         """
         raise NotImplementedError("not yet implemented")
+
+    @staticmethod
+    def reverse_list(head: Node) -> Optional[Node]:
+        """
+        Reverses a linked list given the head node
+        Args:
+            head Node: the head node of the linked list
+        Returns:
+            Optional[Node]: the new head node of the reversed linked list
+        """
+        if head is None or head.next is None:
+            return head
+
+        # track previous node, so we can point our next pointer to it
+        previous = None
+        # track node to loop through
+        current_node = head
+
+        while current_node:
+            # track the next node to not lose it while adjusting pointers
+            nxt = current_node.next
+
+            # set the next pointer to the node behind it, previous
+            current_node.next = previous
+
+            # adjust the new previous node to the current node for subsequent loops
+            previous = current_node
+
+            # move our node pointer up to the next node in front of it
+            current_node = nxt
+
+        # return the new tail of the k-group which is our head
+        return previous

datastructures/linked_lists/singly_linked_list/README.md

@@ -592,3 +592,29 @@ Here `n` is the number of nodes in the linked list
 - Stack
 
 ---
+
+## Reorder List
+
+Given the head of a singly linked list, reorder the list as if it were folded on itself. For example, if the list is 
+represented as follows:
+
+L0 -> L1 -> L2 -> L3 -> L4 -> L5
+
+The reordered list should be:
+
+L0 -> L5 -> L1 -> L4 -> L2 -> L3
+
+You don’t need to modify the values in the list’s nodes; only the links between nodes need to be changed.
+
+### Constraints
+
+- The range of number of nodes in the list is [1, 500]
+- -5000 <= `node.value` <= 5000
+
+### Examples
+
+![Example 1](./images/examples/singly_linked_list_reorder_list_example_1.png)
+![Example 2](./images/examples/singly_linked_list_reorder_list_example_2.png)
+![Example 3](./images/examples/singly_linked_list_reorder_list_example_3.png)
+![Example 4](./images/examples/singly_linked_list_reorder_list_example_4.png)
+![Example 5](./images/examples/singly_linked_list_reorder_list_example_5.png)

datastructures/linked_lists/singly_linked_list/images/examples/singly_linked_list_reorder_list_example_1.png

@@ -4,6 +4,10 @@
 from datastructures.linked_lists.singly_linked_list.node import SingleNode
 from datastructures.linked_lists import LinkedList, T, Node
 from datastructures.linked_lists.exceptions import EmptyLinkedList
+from datastructures.linked_lists.singly_linked_list.single_linked_list_utils import (
+    reverse_list,
+    merge_and_weave,
+)
 
 
 class SinglyLinkedList(LinkedList):
@@ -983,6 +987,36 @@ def reverse_list(head_node: SingleNode) -> SingleNode:
     def remove_tail(self):
         pass
 
+    def reorder_list(self) -> Optional[SingleNode]:
+        """
+        Reorders the linked list in place.
+        Returns:
+            head node of reversed linked list
+        """
+        # return early if there is no head node
+        if self.head is None:
+            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
+        middle_node = self.middle_node()
+
+        # Store the second half head node
+        second_half_head = middle_node.next
+        # cut the connection between the first half and the second half
+        middle_node.next = None
+
+        # Now, we need to reverse the second half of the linked list in place
+        # The reversal step involves taking the second half of the linked list and reversing it in place
+        # for example, if the linked list is 1 -> 2 -> 3 -> 4 -> 5, the second half is 3 -> 4 -> 5
+        # after reversing, it becomes 5 -> 4 -> 3
+        reversed_second_half = self.reverse_list(second_half_head)
+
+        # now we can merge and weave the first half and the reversed second half
+        reordered_list = merge_and_weave(self.head, reversed_second_half)
+
+        return reordered_list
+
     def kth_to_last_node(self, k: int) -> Optional[SingleNode]:
         """
         Gets the Kth to the last node.

datastructures/linked_lists/singly_linked_list/images/examples/singly_linked_list_reorder_list_example_2.png

@@ -0,0 +1,66 @@
+from typing import Optional
+from datastructures.linked_lists.singly_linked_list.node import SingleNode
+
+
+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.
+    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
+    Returns:
+        head node of the merged and weaved linked list
+    """
+    if first_half_head is None or second_half_head is None:
+        return None
+
+    p1 = first_half_head
+    p2 = second_half_head
+
+    while p2:
+        # save the pointer 1 next node to not loose it
+        p1_next = p1.next
+        p2_next = p2.next
+
+        # now we can move the pointers
+        p1.next = p2
+        p2.next = p1_next
+
+        p1, p2 = p1_next, p2_next
+
+    return first_half_head
+
+
+def reverse_list(head: SingleNode) -> Optional[SingleNode]:
+    """
+    Reverses a linked list given the head node
+    Args:
+        head Node: the head node of the linked list
+    Returns:
+        Optional[Node]: the new head node of the reversed linked list
+    """
+    if head is None or head.next is None:
+        return head
+
+    # track previous node, so we can point our next pointer to it
+    previous = None
+    # track node to loop through
+    current_node = head
+
+    while current_node:
+        # track the next node to not lose it while adjusting pointers
+        nxt = current_node.next
+
+        # set the next pointer to the node behind it, previous
+        current_node.next = previous
+
+        # adjust the new previous node to the current node for subsequent loops
+        previous = current_node
+
+        # move our node pointer up to the next node in front of it
+        current_node = nxt
+
+    # return the new tail of the k-group which is our head
+    return previous

datastructures/linked_lists/singly_linked_list/images/examples/singly_linked_list_reorder_list_example_3.png

@@ -0,0 +1,48 @@
+import unittest
+from typing import List
+from parameterized import parameterized
+from datastructures.linked_lists.singly_linked_list.single_linked_list import (
+    SinglyLinkedList,
+)
+
+TEST_CASES = [
+    ([1, 2, 3, 4, 5], [1, 5, 2, 4, 3]),
+    ([1, 2, 3, 4], [1, 4, 2, 3]),
+    ([1, 1, 2, 2, 3, -1, 10, 12], [1, 12, 1, 10, 2, -1, 2, 3]),
+    ([10, 20, -22, 21, -12], [10, -12, 20, 21, -22]),
+    ([1, 3, 5, 7, 9, 10, 8, 6, 4, 2], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]),
+    ([1, 2, 3, 4, 5, 6], [1, 6, 2, 5, 3, 4]),
+    (
+        [7, 0, 10, 13, 12, 19, 1, 3, 6, 7, 4, 2, 11],
+        [7, 11, 0, 2, 10, 4, 13, 7, 12, 6, 19, 3, 1],
+    ),
+    ([0, 8, 3, 1, 2, 7], [0, 7, 8, 2, 3, 1]),
+    ([7, 4, 6, 1, 5, 8], [7, 8, 4, 5, 6, 1]),
+    ([9, 0, 8, 2], [9, 2, 0, 8]),
+    ([6, 8, 7], [6, 7, 8]),
+]
+
+
+class ReorderListTestCase(unittest.TestCase):
+    @parameterized.expand(TEST_CASES)
+    def test_reorder_list(self, input_list: List[int], expected_output: List[int]):
+        linked_list = SinglyLinkedList()
+        for data in input_list:
+            linked_list.append(data)
+
+        actual = linked_list.reorder_list()
+        self.assertIsNotNone(actual)
+
+        # 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 reordering worked
+        actual_list: List[int] = []
+        curr = actual
+        while curr:
+            actual_list.append(curr.data)
+            curr = curr.next
+
+        self.assertEqual(expected_output, actual_list)
+
+
+if __name__ == "__main__":
+    unittest.main()