PU Palindrome Linked List

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode *reverse(struct ListNode *head) {
    struct ListNode *n = 0;
    while (head) {
        struct ListNode *tmp = head->next;
        head->next = n;
        n = head;
        head = tmp;
    }
    return n;
}
bool isPalindrome(struct ListNode* head) {
    if (!head || !head->next) return true;
    struct ListNode *slow = head;
    struct ListNode *fast = head->next;
    while (fast && fast->next) {
        slow = slow->next;
        fast = fast->next->next;
    }
    slow = reverse(slow->next);
    while (slow && slow->val == head->val) {
        slow = slow->next;
        head = head->next;
    }
    return !slow;
}

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
bool isPalindrome(struct ListNode* head) {
    struct ListNode *slow = head, *fast = head;
    head = 0;
    while (fast && fast->next) {
        fast = fast->next->next;
        struct ListNode *p = slow->next;
        slow->next = head;
        head = slow;
        slow = p;
    }
    if (fast) slow = slow->next;
    while (slow && slow->val == head->val) {
        slow = slow->next;
        head = head->next;
    }
    return !slow;
}

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def isPalindrome(self, head):
        """
        :type head: ListNode
        :rtype: bool
        """
        def reverse(head):
            tail, head = head, None
            while tail:
                head, tail.next, tail = tail, head, tail.next
            return head

        if not head or not head.next: return True
        slow, fast = head, head.next
        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
        right = reverse(slow.next)
        while right and right.val == head.val:
            right = right.next
            head = head.next
        return not right

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def isPalindrome(self, head):
        """
        :type head: ListNode
        :rtype: bool
        """
        if not head or not head.next: return True
        slow = fast = head
        left = None
        while fast and fast.next:
            fast = fast.next.next
            left, slow.next, slow = slow, left, slow.next
        if fast: slow = slow.next
        while left and left.val == slow.val:
            left = left.next
            slow = slow.next
        return not left