Add linked list

Author: Zichao Wu

linkedlist-merge/23. Merge k Sorted Lists.py

@@ -1,3 +1,10 @@
+# Definition for singly-linked list.
+from typing import List, Optional
+class ListNode:
+    def __init__(self, val=0, next=None):
+        self.val = val
+        self.next = next
+
 import heapq
 class Solution:
     def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:
@@ -16,8 +23,63 @@ def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:
             res.next = ListNode(topVal)
             res = res.next
 
-            nextNode = lists[i].next            
+            nextNode = lists[i].next
             if nextNode:
                 heapq.heappush(h, (nextNode.val, i))
                 lists[i] = nextNode
         return dummy.next
+
+class Solution:
+    def mergeTwo(self, head1, head2):
+        dummy = ListNode(0)
+        cur = dummy
+
+        # Iterate through both linked lists
+        while head1 and head2:
+            # Add the smaller node to the merged list
+            if head1.val <= head2.val:
+                cur.next = head1
+                head1 = head1.next
+            else:
+                cur.next = head2
+                head2 = head2.next
+            cur = cur.next
+        # If any list is left, append it to
+        # the merged list
+        if head1:
+            cur.next = head1
+        else:
+            cur.next = head2
+
+        # Return the merged list starting
+        # from the next of dummy node
+        return dummy.next
+
+    """
+    Merge linked lists in array[i:j+1]
+    Accepts:
+        arr - array of linked list
+        i - left index in arr, inclusive
+        j - right index in arr, inclusive
+    Returns - head of merged list
+    """
+    def mergeListsRecur(self, i, j, arr):
+        # If single linked list, return its head since it's sorted already
+        if i == j:
+            return arr[i]
+        # Find the middle list
+        mid = i + (j - i) // 2 # [0,1,2] being 1: merge(merge(0+1), 2)
+        # [0,1,2,3] being merge(merge(0,1),merge(2,3))
+        # Merge lists from i to mid
+        head1 = self.mergeListsRecur(i, mid, arr)
+        # Merge lists from mid+1 to j
+        head2 = self.mergeListsRecur(mid + 1, j, arr)
+        # Merge the above 2 lists
+        head = self.mergeTwo(head1, head2)
+        return head
+
+    def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:
+        # Base case for 0 lists to merge
+        if len(lists) == 0:
+            return None
+        return self.mergeListsRecur(0, len(lists) - 1, lists)

linkedlist-reverse/25. Reverse Nodes in k-Group.py

@@ -0,0 +1,90 @@
+# Definition for singly-linked list.
+from typing import Optional
+class ListNode:
+    def __init__(self, val=0, next=None):
+        self.val = val
+        self.next = next
+
+class Solution:
+    # Reverse using Iteration
+    # This solution iterates through the linked list in groups of k nodes,
+    # reversing the links within each group.
+    # It maintains a pointer to the new head of the reversed list and a tail pointer
+    def reverseKGroup(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:
+        if not head or k == 1:
+            return head
+
+        curr = head
+        newHead = None
+        tail = None
+
+        while curr:
+            oldGroupHead = curr
+            prev = None
+            nextNode = None
+            count = 0
+
+            # Reverse the nodes in the current group
+            while curr and count < k:
+                nextNode = curr.next # store ptr to next node temporarily
+                curr.next = prev # reverse the link
+                prev = curr # forward prev ptr to cur node
+                curr = nextNode # forward cur ptr to next node
+                count += 1
+
+            # If newHead is null, set it to the
+            # last node of the first group
+            if not newHead:
+                newHead = prev # will only assigned once per program
+
+            # Connect last group tail (1 and 3 in below example) to the
+            # current reversed group head
+            if tail:
+                # precondition: prev points to the first node of current group we just reversed (4 or 5 in below example)
+                # precondition: tail points to the last node of the reversed previous group (1 or 3 in below example)
+                # precondition: curr points to the first node of the next group (5)
+                # precondition: oldGroupHead points to the first node of current group pre-reversal (1 or 3 in below example)
+                tail.next = prev # 2->1 => 4->3 => 5
+
+            # Move tail to the end   of
+            # the reversed group
+            tail = oldGroupHead
+
+        return newHead
+
+
+    # Reverse using Stack
+    # This is an alternative solution using a stack to reverse the nodes in k-groups.
+    def reverseKGroup(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:
+        if not head or k == 1:
+            return head
+
+        stack = []
+        curr = head
+        prev = None
+
+        while curr:
+
+            # Terminate the loop when either
+            # current == None or count >= k
+            count = 0
+            while curr and count < k:
+                stack.append(curr)
+                curr = curr.next
+                count += 1
+
+            # Now pop the elements from the stack one by one
+            while stack:
+
+                # If the final list has not been started yet
+                if not prev:
+                    prev = stack.pop()
+                    head = prev
+                else:
+                    prev.next = stack.pop()
+                    prev = prev.next
+
+        # Set the next pointer of the last node to None
+        prev.next = None
+
+        return head