先反转后半链表，然后遍历，考虑长度为1的特俗情况

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    bool isPalindrome(ListNode* head) {
        ListNode* current = head;
        int cnt = 0;
        if(current == NULL) return false;
        while(current != NULL)
        {
            cnt ++;
            current = current->next;
        }
        if(cnt <= 1) return true;
        current = head;
        int nowcnt = 1;
        if(cnt % 2 == 0)
        {
            while(nowcnt < cnt / 2 + 1)
            {
                current = current->next;
                nowcnt ++;
            }
        }
        else
        {
            while(nowcnt < cnt / 2 + 2)
            {
                current = current->next;
                nowcnt ++;
            }
        }
        ListNode* pre = NULL;
        ListNode* temp = NULL;
        while(current != NULL)
        {
            temp = current->next;
            current->next = pre;
            pre = current;
            current = temp;
        }

        while(pre != NULL)
        {
            if(pre->val != head->val) return false;
            pre = pre->next;
            head = head->next;
        }
        return true;
    }
};