先用快慢指针确定中间（一个函数），再用反转链表那套反转后半部分（两个函数），最后头尾循环比较（主函数）

/**
 * struct ListNode {
 *    int val;
 *    struct ListNode *next;
 * };
 */

class Solution {
public:
    /**
     * 
     * @param head ListNode类 the head
     * @return bool布尔型
     */
    bool isPail(ListNode* head) {
        // write code here
        if (head == nullptr || head->next == nullptr)
            return true;

        ListNode *midFirst = midmid(head);
        ListNode *rightHead = reverseList(midFirst);
        ListNode *newHead = rightHead;
        midFirst->next = nullptr;

        // 开始比较
        ListNode *leftHead = head;
        while (leftHead != nullptr)
        {
            if (leftHead->val != rightHead-> val)
                return false;
            leftHead = leftHead->next;
            rightHead = rightHead->next;
        }

        reverseList(newHead);

        return true;

    }

    ListNode* midmid(ListNode* head){
        ListNode *fast = head;
        ListNode *slow = head;

        while (fast->next != nullptr && fast->next->next != nullptr)
        {
            slow = slow->next;
            fast = fast->next->next;
        }
        return slow;
    }

    ListNode* reverseList(ListNode* head){
        ListNode *pre = head;
        ListNode *cur = head->next;
        while(cur != nullptr)
        {
            ListNode *temp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = temp;
        }
        return pre;
    }

};