Leetcode 21

Author: Kondareddy1209

Leetcode/Leetcode_21.py

@@ -1,148 +1,237 @@
 """
-LeetCode 21. Merge Two Sorted Lists
+=========================================================
+21. Merge Two Sorted Lists
+LeetCode: https://leetcode.com/problems/merge-two-sorted-lists/
 
-Problem:
-You are given the heads of two sorted linked lists, list1 and list2.
+Approach 1: Brute Force (Create New List)
+Approach 2: Optimal (Iterative In-Place)
 
-Merge the two lists into one sorted linked list and return the head
-of the merged list.
+Author: Your Name
+=========================================================
+
+Problem Statement
+-----------------
+You are given the heads of two sorted linked lists.
+
+Merge the two lists into one sorted linked list by splicing together
+the nodes of the first two lists.
+
+Return the head of the merged linked list.
 
 Example:
 Input:
-list1 = 1 -> 2 -> 4
-list2 = 1 -> 3 -> 4
+List1 = [1,2,4]
+List2 = [1,3,4]
 
 Output:
-1 -> 1 -> 2 -> 3 -> 4 -> 4
+[1,1,2,3,4,4]
+"""
+
+
+# =========================================================
+# Definition for singly-linked list.
+# =========================================================
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
 
----------------------------------------------------------
-Approach: Recursive
----------------------------------------------------------
 
-Idea:
-Since both linked lists are already sorted, compare the current
-nodes of both lists.
+# =========================================================
+# APPROACH 1 : BRUTE FORCE (Create a New Linked List)
+# =========================================================
+"""
+Algorithm
+---------
+1. Create a dummy node.
+2. Traverse both linked lists simultaneously.
+3. Compare current nodes.
+4. Create a new node with the smaller value and attach it.
+5. Move the corresponding pointer.
+6. After one list ends, copy the remaining nodes of the other list.
+7. Return dummy.next.
+
+Time Complexity:
+O(m + n)
+
+Space Complexity:
+O(m + n)
+(New nodes are created.)
+"""
 
-1. If list1's value is smaller (or equal), choose list1's node.
-2. Recursively merge the remaining nodes of list1 with list2.
-3. If list2's value is smaller, choose list2's node.
-4. Recursively merge list1 with the remaining nodes of list2.
-5. Continue until one list becomes empty.
 
-Base Cases:
-- If list1 is empty, return list2.
-- If list2 is empty, return list1.
+class Solution:
+    def mergeTwoLists(self, head1: Optional[ListNode], head2: Optional[ListNode]) -> Optional[ListNode]:
 
-Why it works:
-At every recursive call, the smallest available node is placed
-into the merged list, maintaining sorted order.
+        dummy = ListNode(0)
+        tail = dummy
 
----------------------------------------------------------
-Dry Run
----------------------------------------------------------
+        while head1 and head2:
 
-list1 = 1 -> 2 -> 4
-list2 = 1 -> 3 -> 4
+            if head1.val <= head2.val:
+                tail.next = ListNode(head1.val)
+                head1 = head1.next
+            else:
+                tail.next = ListNode(head2.val)
+                head2 = head2.next
 
-Compare:
-1 <= 1
+            tail = tail.next
 
-Choose first 1
+        while head1:
+            tail.next = ListNode(head1.val)
+            head1 = head1.next
+            tail = tail.next
 
-1 -> merge(2->4, 1->3->4)
+        while head2:
+            tail.next = ListNode(head2.val)
+            head2 = head2.next
+            tail = tail.next
 
-Compare:
-2 > 1
+        return dummy.next
 
-Choose second 1
 
-1 -> merge(2->4, 3->4)
+# =========================================================
+# APPROACH 2 : OPTIMAL (Iterative In-Place)
+# =========================================================
+"""
+Algorithm
+---------
+1. Create a dummy node.
+2. Maintain a tail pointer.
+3. Compare the current nodes of both lists.
+4. Attach the smaller node directly to tail.
+5. Move the corresponding list pointer.
+6. Move tail forward.
+7. Once one list becomes empty, attach the remaining list.
+8. Return dummy.next.
 
-Compare:
-2 <= 3
+Example
+-------
+List1 : 1 -> 2 -> 4
+List2 : 1 -> 3 -> 4
 
-Choose 2
+dummy
 
-2 -> merge(4, 3->4)
+Step 1:
+dummy -> 1
+tail -> 1
 
-Compare:
-4 > 3
+Step 2:
+dummy -> 1 -> 1
 
-Choose 3
+Step 3:
+dummy -> 1 -> 1 -> 2
 
-3 -> merge(4, 4)
+Step 4:
+dummy -> 1 -> 1 -> 2 -> 3
 
-Compare:
-4 <= 4
+Step 5:
+dummy -> 1 -> 1 -> 2 -> 3 -> 4
 
-Choose first 4
+Attach remaining node:
 
-4 -> merge(None, 4)
+dummy -> 1 -> 1 -> 2 -> 3 -> 4 -> 4
 
-Return remaining list:
+Return dummy.next.
+"""
 
-4
 
-Final Result:
+class Solution:
+    def mergeTwoLists(self, head1: Optional[ListNode], head2: Optional[ListNode]) -> Optional[ListNode]:
 
-1 -> 1 -> 2 -> 3 -> 4 -> 4
+        dummy = ListNode(0)
+        tail = dummy
 
----------------------------------------------------------
-Time Complexity: O(m + n)
----------------------------------------------------------
-m = length of list1
-n = length of list2
+        while head1 and head2:
 
-Each node is visited exactly once.
+            if head1.val <= head2.val:
+                tail.next = head1
+                head1 = head1.next
+            else:
+                tail.next = head2
+                head2 = head2.next
 
----------------------------------------------------------
-Space Complexity: O(m + n)
----------------------------------------------------------
-Recursive call stack can grow up to m + n calls.
+            tail = tail.next
 
----------------------------------------------------------
+        # Attach remaining nodes
+        if head1:
+            tail.next = head1
+        else:
+            tail.next = head2
+
+        return dummy.next
+
+
+# =========================================================
+# APPROACH 3 : Recursive
+# =========================================================
+"""
+Algorithm
+---------
+1. If one list is empty, return the other list.
+2. Compare the first nodes.
+3. Recursively merge the remaining lists.
+4. Return the smaller node as the head.
+
+Time Complexity:
+O(m + n)
+
+Space Complexity:
+O(m + n)
+(Recursive call stack)
 """
 
-# Definition for singly-linked list.
-# class ListNode:
-#     def __init__(self, val=0, next=None):
-#         self.val = val
-#         self.next = next
 
 class Solution:
-    def mergeTwoLists(
-        self,
-        list1: Optional[ListNode],
-        list2: Optional[ListNode]
-    ) -> Optional[ListNode]:
+    def mergeTwoLists(self, head1: Optional[ListNode], head2: Optional[ListNode]) -> Optional[ListNode]:
 
-        # Base Case 1:
-        # If list1 is empty, return list2
-        if list1 is None:
-            return list2
+        if head1 is None:
+            return head2
 
-        # Base Case 2:
-        # If list2 is empty, return list1
-        if list2 is None:
-            return list1
+        if head2 is None:
+            return head1
 
-        # Choose the smaller node
-        if list1.val <= list2.val:
+        if head1.val <= head2.val:
+            head1.next = self.mergeTwoLists(head1.next, head2)
+            return head1
+        else:
+            head2.next = self.mergeTwoLists(head1, head2.next)
+            return head2
 
-            # Merge the remaining nodes
-            list1.next = self.mergeTwoLists(
-                list1.next,
-                list2
-            )
 
-            return list1
+# =========================================================
+# Complexity Analysis
+# =========================================================
+"""
+Approach                     Time           Auxiliary Space
+----------------------------------------------------------
+Brute Force                  O(m+n)         O(m+n)
+Optimal Iterative            O(m+n)         O(1)
+Recursive                    O(m+n)         O(m+n)
+
+where,
+m = length of first linked list
+n = length of second linked list
+"""
 
-        else:
 
-            # Merge the remaining nodes
-            list2.next = self.mergeTwoLists(
-                list1,
-                list2.next
-            )
+# =========================================================
+# Key Interview Points
+# =========================================================
+"""
+✓ Dummy node avoids handling special cases for the head.
+
+✓ The iterative approach is the most optimal because:
+   - Every node is visited exactly once.
+   - No extra linked list is created.
+   - No recursion stack is used.
+
+✓ The brute-force approach is easier to understand but
+  requires additional memory.
+
+✓ The recursive solution is elegant but uses O(m+n)
+  auxiliary space due to the recursion stack.
 
-            return list2
+✓ The iterative in-place approach is the solution most
+  interviewers expect.
+"""