Merge pull request #122 from BrianLusina/feat/data-structures-linked-list-reorder-list

feat(data structures, linked list) reorder list

Author: BrianLusina

DIRECTORY.md

@@ -255,13 +255,16 @@
     * Singly Linked List
       * [Node](https://github.com/BrianLusina/PythonSnips/blob/master/datastructures/linked_lists/singly_linked_list/node.py)
       * [Single Linked List](https://github.com/BrianLusina/PythonSnips/blob/master/datastructures/linked_lists/singly_linked_list/single_linked_list.py)
+      * [Single Linked List Utils](https://github.com/BrianLusina/PythonSnips/blob/master/datastructures/linked_lists/singly_linked_list/single_linked_list_utils.py)
       * [Test Singly Linked Delete](https://github.com/BrianLusina/PythonSnips/blob/master/datastructures/linked_lists/singly_linked_list/test_singly_linked_delete.py)
       * [Test Singly Linked List](https://github.com/BrianLusina/PythonSnips/blob/master/datastructures/linked_lists/singly_linked_list/test_singly_linked_list.py)
       * [Test Singly Linked List Nth To Last](https://github.com/BrianLusina/PythonSnips/blob/master/datastructures/linked_lists/singly_linked_list/test_singly_linked_list_nth_to_last.py)
       * [Test Singly Linked List Pairwise Swap](https://github.com/BrianLusina/PythonSnips/blob/master/datastructures/linked_lists/singly_linked_list/test_singly_linked_list_pairwise_swap.py)
       * [Test Singly Linked List Remove Duplicates](https://github.com/BrianLusina/PythonSnips/blob/master/datastructures/linked_lists/singly_linked_list/test_singly_linked_list_remove_duplicates.py)
       * [Test Singly Linked List Remove Nth Last Node](https://github.com/BrianLusina/PythonSnips/blob/master/datastructures/linked_lists/singly_linked_list/test_singly_linked_list_remove_nth_last_node.py)
+      * [Test Singly Linked List Reorder List](https://github.com/BrianLusina/PythonSnips/blob/master/datastructures/linked_lists/singly_linked_list/test_singly_linked_list_reorder_list.py)
       * [Test Singly Linked List Rotate](https://github.com/BrianLusina/PythonSnips/blob/master/datastructures/linked_lists/singly_linked_list/test_singly_linked_list_rotate.py)
+      * [Test Singly Linked Merge And Weave](https://github.com/BrianLusina/PythonSnips/blob/master/datastructures/linked_lists/singly_linked_list/test_singly_linked_merge_and_weave.py)
       * [Test Singly Linked Move Tail To Head](https://github.com/BrianLusina/PythonSnips/blob/master/datastructures/linked_lists/singly_linked_list/test_singly_linked_move_tail_to_head.py)
       * [Test Singly Linked Palindrome](https://github.com/BrianLusina/PythonSnips/blob/master/datastructures/linked_lists/singly_linked_list/test_singly_linked_palindrome.py)
       * [Test Singly Linked Revese](https://github.com/BrianLusina/PythonSnips/blob/master/datastructures/linked_lists/singly_linked_list/test_singly_linked_revese.py)

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