方法：快慢指针+递归+遍历

/**
 * 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:
    // int ListLength=0;
    ListNode* reverseList(ListNode* head){
        if(!head||!head->next){
            // if(head){
            //     ListLength+=1;
            // }
            return head;
        }
        ListNode* T=reverseList(head->next);
        head->next->next=head;
        head->next=nullptr;
        // ListLength+=1;
        return T;
    }
    bool isPalindrome(ListNode* head) {
        if(!head||!head->next){
            return true;
        }
        ListNode* secondStart=searchHalfStart(head);
        ListNode* b=reverseList(secondStart->next);
        ListNode* a=head;
        int eqIndex=0;
        // while(b){
        //     std::cout<<"<<<"<<b->val<<std::endl;
        //     // a=a->next;
        //     b=b->next;
        // }
        bool res=true;
        while(res && a && b){
            // std::cout<<eqIndex<<","<<ListLength<<std::endl;
            // std::cout<<a->val<<"---"<<b->val<<std::endl;
            if(a->val == b->val){
                // eqIndex+=1;
                res=true;
                a=a->next;
                b=b->next;
                // std::cout<<"222"<<std::endl;
            }
            else{
                res=false;
                break;
            }
        }
        reverseList(secondStart);
        // std::cout<<eqIndex<<","<<ListLength<<std::endl;
        return res;

    }

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

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

方法：递归回退策略

/**
 * 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:
    ListNode* frontPoint;
    bool recurveCheck(ListNode* head){
        if(!head){
            return true;
        }
        else{
            bool res=recurveCheck(head->next);
            if(res && head->val==frontPoint->val){
                frontPoint=frontPoint->next;
                return res;
            }
            else{
                return false;
            }
        }
    }

    bool isPalindrome(ListNode* head) {
        if(!head||!head->next){
            return true;
        }
        frontPoint = head;
        bool res = recurveCheck(head);
        return res;

    }
};

方法：容器数组+遍历

/**
 * 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) {
        vector<int> vec;
        ListNode* temp=head;
        while(temp!=nullptr){
            vec.emplace_back(temp->val);
            temp=temp->next;
        }
        bool res=true;
        int i=0,j=vec.size()-1;
        while(i<j){
            if(vec.at(i)==vec.at(j)){
                i++;
                j--;
            }
            else{
                res=false;
                break;
            }
        }
        return res;

    }
};