234. 回文链表 Palindrome Linked List - 简单

最新推荐文章于 2025-02-27 21:05:06 发布

m0_62024778

最新推荐文章于 2025-02-27 21:05:06 发布

阅读量96

点赞数

分类专栏： leetcode 文章标签：链表 list 算法

本文链接：https://blog.csdn.net/m0_62024778/article/details/121200561

版权

leetcode 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

这篇博客介绍了如何判断一个单链表是否为回文，提供了两种解题方法：递归法和快慢指针法。递归法通过从中间节点开始递归检查左右子链表的回文性质；快慢指针法则先找到链表中点，然后翻转后半部分链表进行比较。两种方法的时间复杂度均为O(N)，但空间复杂度不同，递归法为O(N)，快慢指针法为O(1)。

摘要由CSDN通过智能技术生成

题目描述

Given the head of a singly linked list, return true if it is a palindrome.
Example 1:

Input: head = [1,2,2,1]
Output: true

Example 2:

Input: head = [1,2]
Output: false

Constraints:

The number of nodes in the list is in the range [1, 10⁵].
0 <= Node.val <= 9

Follow up: Could you do it in O(n) time and O(1) space?
Constraints:

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/palindrome-linked-list
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题方法

递归法

/**
 * 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 recursivelyCheck(ListNode* right) {
        if(right == nullptr) return true;
        bool res = recursivelyCheck(right->next);
        res = res && (left->val == right->val);
        left = left->next;
        return res;
    }
    bool isPalindrome(ListNode* head) {
        left = head;
        return recursivelyCheck(head);
    }
};

时间复杂度：O(N)。
空间复杂度：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* reverseList(ListNode* head) {
        ListNode* pre = nullptr;
        ListNode* cur = head;
        ListNode* next;
        while(cur) {
            next = cur->next;
            cur->next = pre;
            pre = cur;
            cur = next;
        }
        return pre;
    }

    bool isPalindrome(ListNode* head) {
        ListNode* slow = head;
        ListNode* fast = head;
        ListNode* p; //p为恢复链表结构作准备
        while(fast != nullptr && fast->next != nullptr) {
            p = slow;
            slow = slow->next;
            fast = fast->next->next;
        }
        if(fast != nullptr) {
            p = slow;
            slow = slow->next;
        }
        ListNode* left = head;
        ListNode* right = reverseList(slow);
        ListNode* q = right;
        bool flag = true;
        while(right != nullptr) {
            if(left->val != right->val) {
                flag = false;
            }
            else
                flag = true && flag;
            right = right->next;
            left = left->next;
        }
        p->next = reverseList(q);
        return flag;
    }
};