回文 链表

暴力解法复制一个新的链表出来并将其反转，然后挨个元素进行比较。比较是否是回文链表，实际上是在比较链表节点 val 的值是否相等，那么只需遍历一次链表，将其val存放在数组中，然后去判断这个数组是否回文。

//赋值链表，将其反转
class Solution {
public:
    ListNode* reverse(ListNode* cur, ListNode* pre) {
        if(cur == nullptr) {
            return pre;
        }
        ListNode* tmp = cur->next;
        cur->next = pre;
        return reverse(tmp, cur);
    }

    ListNode* copyList(ListNode* head) {
        if(head == nullptr) {
            return nullptr;
        }
        ListNode* newHead = new ListNode(head->val);
        ListNode* curr = newHead;
        head = head->next;
        while(head != nullptr) {
            curr->next = new ListNode(head->val);
            curr = curr->next;
            head = head->next;
        }
        return newHead;
    }

    bool isPalindrome(ListNode* head) {
        // Create a copy of the original list and reverse it
        ListNode* headCopy = copyList(head);
        ListNode* headReverse = reverse(headCopy, nullptr);

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

//遍历链表，将val放在数组进行比较
class Solution {
public:
    bool isPalindrome(ListNode* head) {
        vector<int> vals;
        while (head != nullptr) {
            vals.emplace_back(head->val);
            head = head->next;
        }
        for (int i = 0, j = (int)vals.size() - 1; i < j; ++i, --j) {
            if (vals[i] != vals[j]) {
                return false;
            }
        }
        return true;
    }
};

上述的写法都需要额外的空间来存放val，其实判断是否回文，只需要判断链表的前半部分和后半部分是否相等，那么只需要将链表的后半部分反转，然后依次进行比较，这样就不必花费额外的空间。
可以使用快慢指针的方法找到链表后半部分的头节点

class Solution {
public:
    bool isPalindrome(ListNode* head) {
        if (head == nullptr) {
            return true;
        }

        // 找到前半部分链表的尾节点并反转后半部分链表
        ListNode* firstHalfEnd = endOfFirstHalf(head);
        ListNode* secondHalfStart = reverseList(firstHalfEnd->next);

        // 判断是否回文
        ListNode* p1 = head;
        ListNode* p2 = secondHalfStart;
        bool result = true;
        while (result && p2 != nullptr) {
            if (p1->val != p2->val) {
                result = false;
            }
            p1 = p1->next;
            p2 = p2->next;
        }        
        return result;
    }

    ListNode* reverseList(ListNode* head) {
        ListNode* prev = nullptr;
        ListNode* curr = head;
        while (curr != nullptr) {
            ListNode* nextTemp = curr->next;
            curr->next = prev;
            prev = curr;
            curr = nextTemp;
        }
        return prev;
    }

    ListNode* endOfFirstHalf(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;
    }
};