Leetcode 234

Author: Kondareddy1209

Leetcode/Leetcode_234.py

@@ -0,0 +1,164 @@
+# ============================================================
+# LeetCode 234. Palindrome Linked List
+# ============================================================
+#
+# Problem:
+# Given the head of a singly linked list, return True if it is
+# a palindrome, otherwise return False.
+#
+# ------------------------------------------------------------
+# Approach: Fast & Slow Pointer + Reverse Second Half
+# ------------------------------------------------------------
+#
+# Algorithm:
+#
+# 1. Find the middle of the linked list using two pointers.
+#    - slow moves one step.
+#    - fast moves two steps.
+#
+# 2. If the list has an odd number of nodes,
+#    skip the middle node because it does not affect
+#    palindrome comparison.
+#
+# 3. Reverse the second half of the linked list.
+#
+# 4. Compare the first half and the reversed second half.
+#    - If any values differ -> return False.
+#    - Otherwise return True.
+#
+# ------------------------------------------------------------
+# Example
+# ------------------------------------------------------------
+#
+# Input:
+#
+# 1 -> 2 -> 2 -> 1
+#
+# Step 1: Find Middle
+#
+# slow
+#   |
+# 1 -> 2 -> 2 -> 1
+#
+# Step 2: Reverse Second Half
+#
+# First Half:
+# 1 -> 2
+#
+# Second Half:
+# 1 -> 2
+#
+# Step 3: Compare
+#
+# 1 == 1
+# 2 == 2
+#
+# Output:
+# True
+#
+# ------------------------------------------------------------
+# Dry Run (Odd Length)
+# ------------------------------------------------------------
+#
+# Input:
+#
+# 1 -> 2 -> 3 -> 2 -> 1
+#
+# Middle = 3
+#
+# Skip middle
+#
+# Reverse:
+#
+# 2 -> 1
+#
+# becomes
+#
+# 1 -> 2
+#
+# Compare:
+#
+# Left : 1 -> 2
+# Right: 1 -> 2
+#
+# Every node matches.
+#
+# Output:
+# True
+#
+# ------------------------------------------------------------
+# Time Complexity
+# ------------------------------------------------------------
+#
+# Finding Middle      : O(n)
+# Reversing Half      : O(n/2)
+# Comparing Halves    : O(n/2)
+#
+# Total Time:
+# O(n)
+#
+# ------------------------------------------------------------
+# Space Complexity
+# ------------------------------------------------------------
+#
+# O(1)
+#
+# Only a few pointers are used.
+# No extra array or stack.
+#
+# ============================================================
+
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+
+class Solution:
+    def isPalindrome(self, head: Optional[ListNode]) -> bool:
+
+        # Empty list or single node is always a palindrome.
+        if not head or not head.next:
+            return True
+
+        # ----------------------------------------------------
+        # Step 1: Find the middle of the linked list
+        # ----------------------------------------------------
+        fast = head
+        slow = head
+
+        while fast and fast.next:
+            slow = slow.next
+            fast = fast.next.next
+
+        # If fast is not None, the list contains
+        # an odd number of nodes.
+        # Skip the middle node.
+        if fast:
+            slow = slow.next
+
+        # ----------------------------------------------------
+        # Step 2: Reverse the second half
+        # ----------------------------------------------------
+        prev = None
+
+        while slow:
+            nxt = slow.next
+            slow.next = prev
+            prev = slow
+            slow = nxt
+
+        # ----------------------------------------------------
+        # Step 3: Compare both halves
+        # ----------------------------------------------------
+        left = head
+        right = prev
+
+        while right:
+            if left.val != right.val:
+                return False
+
+            left = left.next
+            right = right.next
+
+        return True