剑指 Offer II 027. 回文链表

题目链接

剑指 Offer II 027. 回文链表 easy

题目描述

给定一个链表的 头节点 head，请判断其是否为回文链表。

如果一个链表是回文，那么链表节点序列从前往后看和从后往前看是相同的。

示例 1：

输入: head = [1,2,3,3,2,1]
输出: true

示例 2：

输入: head = [1,2]
输出: false

提示：

• 链表 L的长度范围为 $[1,10^5]$
• $0<=node.val<=9$

解法一：栈

先用 快慢指针 找到链表的中点，然后将其分为前后两段。

然后再将第二段的结点放到一个栈 stack中。

最后从第一段的头结点开始 和 栈顶结点 进行比较即可。

可以参考这一篇 剑指 Offer II 026. 重排链表

时间复杂度： $O(n)$

代码：

/**
 * 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 *fast = head , *slow = head , *pre = head;
        while(fast && fast->next){
            pre = slow;
            fast = fast->next->next;
            slow = slow->next;
        }

        if(fast){
            pre = slow;
            slow = slow->next;
            pre->next = nullptr;
        }
        else{
            pre->next = nullptr;
        }

        //用栈来存储结点
        stack<int> stk;
        while(slow){
            stk.push(slow->val);
            slow = slow->next;
        }

        //比较
        ListNode *cur = head;
        while(!stk.empty()){
            int val = stk.top();
            stk.pop();
            if(cur->val != val) return false;
            cur = cur->next;
        }

        return true;
    }
};

解法二：反转链表

先用 快慢指针 找到链表的中点，然后将其分为前后两段。

然后再将第二段进行 反转。

最后从第一段的头结点 和 反转后的第二段头结点 开始进行比较即可。

可以参考这一篇 剑指 Offer II 024. 反转链表

时间复杂度： $O(n)$

代码：

/**
 * 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* reverse(ListNode *head){
        ListNode * cur = head , *pre = nullptr;
        while(cur){
            ListNode *nextNode = cur->next;
            cur->next = pre;
            pre = cur;
            cur = nextNode;
        }
        return pre;
    }
    bool isPalindrome(ListNode* head) {
        ListNode *fast = head , *slow = head , *pre = head;
        while(fast && fast->next){
            pre = slow;
            fast = fast->next->next;
            slow = slow->next;
        }

        if(fast){
            pre = slow;
            slow = slow->next;
            pre->next = nullptr;
        }
        else{
            pre->next = nullptr;
        }

        ListNode *b = reverse(slow);
        ListNode *a = head;

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