Leetcode234 回文链表

虽然是一道简单题，但是综合性太强了，设计到链表里面很多技巧与操作。

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:
    ListNode* left;
    bool isPalindrome(ListNode* head) {
        left = head;
        return backtrack(head);
    }
    
    // 此处类似二叉树的后续遍历，递归会使得直接递归到链表的末尾
    // 再利用类内指向链表头部的成员变量与其对比
    bool backtrack(ListNode* right) {
        if (right == nullptr)
            return true;
        bool res = backtrack(right->next);
        res = res && (right->val == left->val);
        left = left->next;
        return res;
    }
};

2、反转 + 回文比较

/**
 * 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) {
        // 1、双指针找到中心点（注意区分节点的奇偶数）
        ListNode* fast = head, *slow = head;
        while (fast && fast->next) {
            slow = slow->next;
            fast = fast->next->next;
        }
        // 遇到偶数个节点的情况 fast == nullptr
        // 遇到奇数个节点的情况 fast != nullptr
        if (fast)   slow = slow->next;

        // 2、翻转后半部分链表 slow--->末尾
        ListNode* pre = nullptr, *cur = slow;
        while (cur != nullptr) {
            ListNode* next = cur->next;
            cur->next = pre;
            pre = cur;
            cur = next;
        }

        // 3、回文比较
        while (pre) {
            if (pre->val != head->val)
                return false;
            pre = pre->next;
            head = head->next;
        }
        return true;

    }
};