Palindrome Linked List

class Solution {
public:
    bool isPalindrome(ListNode* head) {
        ListNode *slow = head, *fast = head;
        while (fast && fast->next) {
            slow = slow->next;
            fast = fast->next->next;
        }
        // Reverse from slow to end.
        ListNode* prev = nullptr;
        while (slow) {
            ListNode* nxt = slow->next;
            slow->next = prev;
            prev = slow;
            slow = nxt;
        }
        // Compare halves.
        ListNode *a = head, *b = prev;
        while (b) {
            if (a->val != b->val) return false;
            a = a->next; b = b->next;
        }
        return true;
    }
};

func isPalindrome(head *ListNode) bool {
    slow, fast := head, head
    for fast != nil && fast.Next != nil {
        slow = slow.Next
        fast = fast.Next.Next
    }
    // Reverse from slow to end.
    var prev *ListNode
    for slow != nil {
        nxt := slow.Next
        slow.Next = prev
        prev = slow
        slow = nxt
    }
    // Compare halves.
    a, b := head, prev
    for b != nil {
        if a.Val != b.Val {
            return false
        }
        a = a.Next
        b = b.Next
    }
    return true
}

from typing import Optional

class Solution:
    def isPalindrome(self, head: Optional[ListNode]) -> bool:
        slow, fast = head, head
        while fast is not None and fast.next is not None:
            slow = slow.next
            fast = fast.next.next
        # Reverse from slow to end.
        prev = None
        while slow is not None:
            nxt = slow.next
            slow.next = prev
            prev = slow
            slow = nxt
        # Compare halves.
        a, b = head, prev
        while b is not None:
            if a.val != b.val:
                return False
            a = a.next
            b = b.next
        return True

function isPalindrome(head) {
    let slow = head, fast = head;
    while (fast !== null && fast.next !== null) {
        slow = slow.next;
        fast = fast.next.next;
    }
    // Reverse from slow to end.
    let prev = null;
    while (slow !== null) {
        const nxt = slow.next;
        slow.next = prev;
        prev = slow;
        slow = nxt;
    }
    // Compare halves.
    let a = head, b = prev;
    while (b !== null) {
        if (a.val !== b.val) return false;
        a = a.next;
        b = b.next;
    }
    return true;
}

class Solution {
    public boolean isPalindrome(ListNode head) {
        ListNode slow = head, fast = head;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        // Reverse from slow to end.
        ListNode prev = null;
        while (slow != null) {
            ListNode nxt = slow.next;
            slow.next = prev;
            prev = slow;
            slow = nxt;
        }
        // Compare halves.
        ListNode a = head, b = prev;
        while (b != null) {
            if (a.val != b.val) return false;
            a = a.next;
            b = b.next;
        }
        return true;
    }
}

function isPalindrome(head: ListNode | null): boolean {
    let slow: ListNode | null = head, fast: ListNode | null = head;
    while (fast !== null && fast.next !== null) {
        slow = slow!.next;
        fast = fast.next.next;
    }
    // Reverse from slow to end.
    let prev: ListNode | null = null;
    while (slow !== null) {
        const nxt: ListNode | null = slow.next;
        slow.next = prev;
        prev = slow;
        slow = nxt;
    }
    // Compare halves.
    let a: ListNode | null = head, b: ListNode | null = prev;
    while (b !== null) {
        if (a!.val !== b.val) return false;
        a = a!.next;
        b = b.next;
    }
    return true;
}