LeetCode第 234 题：回文链表(C++)

234. 回文链表 - 力扣（LeetCode）

如果不要求空间复杂度，那遍历一遍放入字符串或者栈操作判断回文串即可。

如果要求常数空间复杂度，就只能原地操作了，具体怎么操作呢？

先遍历一次找到长度，就可以根据长度定位到链表中点，将中点左边的链表进行反转，然后从中点往两边比较即可。

class Solution {
public:
    bool isPalindrome(ListNode* head) {
        if(!head || !head->next)   return true;
        int len = 0;
        ListNode* cur = head;
        while(cur){
            ++len;
            cur = cur->next;
        }
        ListNode* left = head;//左边的中点
        for(int i = 0; i < len/2-1;++i){//寻找中间节点
            left = left->next;
        }
        ListNode* right = new ListNode(-1);//右边的中点
        if(len%2){ //节点为奇数个
            left = left->next;//left现在指向中间
            right->next = left->next;//断开，后半部分接到right后面
            right->val = left->val;//赋相同的值是为了方便比较
        }
        else right = left->next;//节点为偶数个

        auto pre = head;
        cur = head->next;
        while(pre!= left){//翻转前半部分
            auto tmp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = tmp;
        }
        head->next = NULL;//前半部分末尾的处理

        while(right){
            if(left->val != right->val) return false;
            left = left->next;
            right = right->next;
        }
        return true;
    }
};

进行一下优化，首先寻找中间节点其实一次遍历就可以，使用快慢指针法：

class Solution {
public:
    bool isPalindrome(ListNode* head) {
        if(!head || !head->next)   return true;
        ListNode *slow = head, *fast = head->next;
        while(fast && fast->next){
            slow = slow->next;
            fast = fast->next->next;
        }//slow指向中点或者左中点
        ListNode *left = slow;//左边的起点
        ListNode *right = new ListNode();//右半部分起点
        if(!fast){
            right->next = slow->next;
            right->val = slow->val;//赋相同的值是为了方便比较
        }
        else    right = left->next;

        ListNode *pre = NULL, *cur = head;
        while(pre!= left){//翻转左半部分
            auto tmp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = tmp;
        }

        while(right){
            if(left->val != right->val) return false;
            left = left->next;
            right = right->next;
        }
        return true;
    }
};

还能再优化，上面的节点处理可以翻转右半部分

class Solution {
public:
    bool isPalindrome(ListNode* head) {
        if(!head || !head->next)   return true;
        ListNode *slow = head, *fast = head->next;
        while(fast && fast->next){
            slow = slow->next;
            fast = fast->next->next;
        }//slow指向中点或者左中点

        ListNode *pre = NULL;
        while(slow){//翻转右半部分
            auto tmp = slow->next;
            slow->next = pre;
            pre = slow;
            slow = tmp;
        }

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

最后一种方式是最简洁的，处理完的节点大概是这样：

最后是否需要再恢复链表的原始结构就看情况了。

又看到了这儿的题解：回文链表（1.栈，2.快慢指针+翻转） - 回文链表 - 力扣（LeetCode）

上述的翻转过程其实可以在快慢指针走的同时就进行翻转，之前一直没想到：

class Solution {
public:
    bool isPalindrome(ListNode* head) {
        if(!head || !head->next)   return true;
        ListNode *slow = head, *fast = head;
        ListNode *p, *pre = NULL;
        while(fast && fast->next){//快慢指针一边遍历一遍翻转
            p = slow;
            slow = slow->next;
            fast = fast->next->next;
            p->next = pre;
            pre = p;
        }//slow指向中点或者右中点
        if(fast)    slow = slow->next;//此时节点个数为计数，跳过正中间节点
        //翻转之后p和slow分别是两部分的头
        while(p){
            if(p->val != slow->val) return false;
            p = p->next;
            slow = slow->next;
        }
        return true;
    }
};