Leetcode 24

Author: Kondareddy1209

Leetcode/Leetcode_24.py

@@ -0,0 +1,246 @@
+# ============================================================
+# 24. Swap Nodes in Pairs
+# LeetCode: https://leetcode.com/problems/swap-nodes-in-pairs/
+#
+# Approach:
+# ----------
+# We use a dummy node to simplify swapping the first pair.
+#
+# For every iteration:
+#
+# Before Swap:
+#
+# prev
+#  |
+#  v
+# dummy -> 1 -> 2 -> 3 -> 4
+#          ^    ^
+#       first second
+#
+# Step 1:
+# first.next = second.next
+#
+# dummy -> 1 -----> 3 -> 4
+#            \
+#             X
+#              2
+#
+# Step 2:
+# second.next = first
+#
+# dummy    2 -> 1 -> 3 -> 4
+#
+# Step 3:
+# prev.next = second
+#
+# dummy -> 2 -> 1 -> 3 -> 4
+#
+# Move prev to the end of the swapped pair:
+#
+# prev = first
+#
+# Repeat until fewer than two nodes remain.
+#
+# ------------------------------------------------------------
+# Time Complexity : O(n)
+#   - Each node is visited exactly once.
+#
+# Space Complexity : O(1)
+#   - Only a few pointers are used.
+# ============================================================
+
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+
+
+class Solution:
+    def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        # --------------------------------------------------------
+        # Step 1: Create a dummy node before the head.
+        # This helps handle swapping the first pair easily.
+        # --------------------------------------------------------
+        dummy = ListNode(0)
+        dummy.next = head
+
+        # Pointer used to traverse the list.
+        prev = dummy
+
+        # --------------------------------------------------------
+        # Continue while there are at least two nodes to swap.
+        # --------------------------------------------------------
+        while prev.next and prev.next.next:
+
+            # First and second nodes of the current pair
+            first = prev.next
+            second = first.next
+
+            # ----------------------------------------------------
+            # Swap the two nodes
+            # ----------------------------------------------------
+
+            # Connect first node to the node after second
+            first.next = second.next
+
+            # Put second before first
+            second.next = first
+
+            # Connect previous part to second
+            prev.next = second
+
+            # Move prev to the end of the swapped pair
+            prev = first
+
+        # New head of the modified list
+        return dummy.next
+
+
+"""
+==========================
+Example Dry Run
+==========================
+
+Input:
+1 -> 2 -> 3 -> 4
+
+Initial:
+
+dummy -> 1 -> 2 -> 3 -> 4
+ ^
+prev
+
+
+--------------------------------
+Iteration 1
+--------------------------------
+
+first  = 1
+second = 2
+
+Step 1:
+first.next = second.next
+
+1 -> 3
+
+Step 2:
+second.next = first
+
+2 -> 1 -> 3
+
+Step 3:
+prev.next = second
+
+dummy -> 2 -> 1 -> 3 -> 4
+
+Move:
+prev = first
+
+dummy -> 2 -> 1 -> 3 -> 4
+              ^
+             prev
+
+
+--------------------------------
+Iteration 2
+--------------------------------
+
+first = 3
+second = 4
+
+Step 1:
+3.next = None
+
+Step 2:
+4.next = 3
+
+Step 3:
+1.next = 4
+
+Result:
+
+dummy -> 2 -> 1 -> 4 -> 3
+
+Move:
+prev = 3
+
+Loop Ends.
+
+Return:
+dummy.next
+
+Output:
+2 -> 1 -> 4 -> 3
+
+
+==========================
+Edge Cases
+==========================
+
+Case 1:
+Input:
+[]
+
+Output:
+[]
+
+--------------------------------
+
+Case 2:
+Input:
+[1]
+
+Output:
+[1]
+
+--------------------------------
+
+Case 3:
+Input:
+[1,2]
+
+Output:
+[2,1]
+
+--------------------------------
+
+Case 4:
+Input:
+[1,2,3]
+
+Output:
+[2,1,3]
+
+--------------------------------
+
+Case 5:
+Input:
+[1,2,3,4,5]
+
+Output:
+[2,1,4,3,5]
+
+
+==========================
+Complexity Analysis
+==========================
+
+Time Complexity:
+O(n)
+
+Reason:
+- Every node is processed exactly once.
+- Each swap takes constant time.
+
+Space Complexity:
+O(1)
+
+Reason:
+- No extra list or recursion is used.
+- Only four pointers are maintained:
+    • dummy
+    • prev
+    • first
+    • second
+"""