前言
简单 √ 是反转链表的衍生题，很快写完了。不过没考虑到恢复链表结构的问题。
题目
给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false 。
示例 1：
输入：head = [1,2,2,1] 输出：true
示例 2：
输入：head = [1,2] 输出：false
提示：
- 链表中节点数目在范围
[1, 105]内 0 <= Node.val <= 9
进阶：你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？
思路
一开始想着把链表直接反转存储，然后同时遍历。但是考虑到题目要求的O（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:bool isPalindrome(ListNode* head) {if (!head || !head->next){return true;}//链表长度ListNode* node = head;int count = 1;while (node->next){node = node->next;count++;}//反转一半的链表，分奇偶两种情况int len = count / 2;ListNode* pre = nullptr;ListNode* cur = head;while (len--){ListNode* nextnode = cur->next;cur->next = pre;pre = cur;cur = nextnode;}ListNode* left = pre;ListNode* right = cur;if (count % 2 != 0){right = right->next;}//左右同时开始遍历while (left && right){if (left->val != right->val){return false;}left = left->next;right = right->next;}return true;}
};官方题解
将值复制到数组中后用双指针法
- 复制链表值到数组列表中。
- 使用双指针法判断是否为回文。
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;}
};快慢指针
- 找到前半部分链表的尾节点。
- 反转后半部分链表。
- 判断是否回文。
- 恢复链表。
- 返回结果。
跟笔者思路差不多，不过多了还原链表结构的步骤
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;} // 还原链表并返回结果firstHalfEnd->next = reverseList(secondHalfStart);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;}
};心得
有了反转链表的基础，思路就很快想到了。一半反转，同时遍历即可。但是笔者没考虑到还原链表结构，这里暴露出笔者缺乏全局思考，代码拓展性的问题，纯粹是为了做题而做题，有点丢了本心，警醒！另外，反转链表还有个缺点就是需要锁定整个链表来解答，对于系统也不友好。最后，这里再加一个用栈的做法，比数组的做法更好，不过不是O（1）空间复杂度。
