Leetcode 143

Author: Kondareddy1209

Leetcode/Leetcode_143.py

@@ -0,0 +1,335 @@
+"""
+=========================================================
+LeetCode 143. Reorder List
+=========================================================
+
+Problem:
+Reorder a singly linked list from:
+
+    L0 → L1 → L2 → ... → Ln
+
+to
+
+    L0 → Ln → L1 → Ln-1 → L2 → Ln-2 → ...
+
+The list must be modified in-place without changing node values.
+
+---------------------------------------------------------
+Approach 1 : Stack + Queue (pop() + pop(0))
+---------------------------------------------------------
+
+Idea:
+1. Store every node in a list.
+2. Keep the first node as the head.
+3. Alternate between:
+      - Taking the last node (pop())
+      - Taking the first remaining node (pop(0))
+4. Connect them one after another.
+
+Example:
+
+Original:
+1 → 2 → 3 → 4 → 5
+
+Stored:
+[1,2,3,4,5]
+
+After removing first node:
+[2,3,4,5]
+
+Connect:
+
+1 → 5
+5 → 2
+2 → 4
+4 → 3
+
+Result:
+
+1 → 5 → 2 → 4 → 3
+
+Time Complexity:
+    O(n²)
+Reason:
+    pop()   -> O(1)
+    pop(0)  -> O(n)
+    pop(0) is executed nearly n/2 times.
+
+Space Complexity:
+    O(n)
+
+=========================================================
+"""
+
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+
+from typing import Optional
+
+
+class SolutionStackQueue:
+    def reorderList(self, head: Optional[ListNode]) -> None:
+        if not head or not head.next:
+            return
+
+        nodes = []
+
+        curr = head
+        while curr:
+            nodes.append(curr)
+            curr = curr.next
+
+        curr = head
+        nodes.pop(0)
+
+        while nodes:
+            curr.next = nodes.pop()
+            curr = curr.next
+
+            if nodes:
+                curr.next = nodes.pop(0)
+                curr = curr.next
+
+        curr.next = None
+
+
+"""
+=========================================================
+Approach 2 : Array + Two Pointers
+(Optimal Brute Force)
+=========================================================
+
+Idea:
+1. Store every node inside an array.
+2. Remove the first node because head is already fixed.
+3. Use two pointers:
+       i -> first remaining node
+       j -> last remaining node
+4. Alternate between:
+       nodes[j]
+       nodes[i]
+
+Example:
+
+Original:
+
+1 → 2 → 3 → 4 → 5
+
+Array:
+
+[2,3,4,5]
+
+i = 0
+j = 3
+
+Connect:
+
+1 → 5
+5 → 2
+2 → 4
+4 → 3
+
+Result:
+
+1 → 5 → 2 → 4 → 3
+
+Time Complexity:
+    O(n)
+
+Reason:
+    Every node is visited only once.
+
+Space Complexity:
+    O(n)
+
+=========================================================
+"""
+
+
+class SolutionArray:
+    def reorderList(self, head: Optional[ListNode]) -> None:
+        if not head or not head.next:
+            return
+
+        nodes = []
+
+        curr = head
+        while curr:
+            nodes.append(curr)
+            curr = curr.next
+
+        curr = head
+        nodes.pop(0)
+
+        i = 0
+        j = len(nodes) - 1
+
+        while i <= j:
+            curr.next = nodes[j]
+            curr = curr.next
+            j -= 1
+
+            if i <= j:
+                curr.next = nodes[i]
+                curr = curr.next
+                i += 1
+
+        curr.next = None
+
+
+"""
+=========================================================
+Approach 3 : Optimal (Find Middle + Reverse + Merge)
+=========================================================
+
+Idea:
+
+Step 1:
+Find the middle using Slow & Fast pointers.
+
+Example:
+
+1 → 2 → 3 → 4 → 5
+          ↑
+        slow
+
+---------------------------------------------------------
+
+Step 2:
+Reverse the second half.
+
+Before:
+
+4 → 5
+
+After:
+
+5 → 4
+
+Now we have
+
+First Half:
+1 → 2 → 3
+
+Second Half:
+5 → 4
+
+---------------------------------------------------------
+
+Step 3:
+Merge both halves alternately.
+
+1 → 5
+↓
+
+2 → 4
+↓
+
+3
+
+Final:
+
+1 → 5 → 2 → 4 → 3
+
+---------------------------------------------------------
+
+Dry Run
+
+Input:
+
+1 → 2 → 3 → 4 → 5
+
+Find Middle
+
+First Half:
+1 → 2 → 3
+
+Second Half:
+4 → 5
+
+Reverse
+
+5 → 4
+
+Merge
+
+Iteration 1
+
+1 → 5 → 2
+
+Iteration 2
+
+2 → 4 → 3
+
+Final
+
+1 → 5 → 2 → 4 → 3
+
+---------------------------------------------------------
+
+Time Complexity:
+    O(n)
+
+Reason:
+    Find middle      -> O(n)
+    Reverse          -> O(n)
+    Merge            -> O(n)
+
+Total:
+    O(n)
+
+Space Complexity:
+    O(1)
+
+This is the expected interview solution.
+
+=========================================================
+"""
+
+
+class SolutionOptimal:
+    def reorderList(self, head: Optional[ListNode]) -> None:
+        if not head or not head.next:
+            return
+
+        # -------------------------------------------------
+        # Step 1: Find Middle
+        # -------------------------------------------------
+        slow = head
+        fast = head
+
+        while fast and fast.next:
+            slow = slow.next
+            fast = fast.next.next
+
+        # -------------------------------------------------
+        # Step 2: Reverse Second Half
+        # -------------------------------------------------
+        prev = None
+        curr = slow.next
+        slow.next = None
+
+        while curr:
+            nxt = curr.next
+            curr.next = prev
+            prev = curr
+            curr = nxt
+
+        # -------------------------------------------------
+        # Step 3: Merge Two Halves
+        # -------------------------------------------------
+        first = head
+        second = prev
+
+        while second:
+            temp1 = first.next
+            temp2 = second.next
+
+            first.next = second
+            second.next = temp1
+
+            first = temp1
+            second = temp2