Leetcode 234. 回文链表(进阶)
Posted Timothy_Prayer
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Leetcode 234. 回文链表(进阶)相关的知识，希望对你有一定的参考价值。
题目描述：
请判断一个链表是否为回文链表。
示例 1:
输入: 1->2 输出: false
示例 2:
输入: 1->2->2->1 输出: true
进阶：
你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？
解法一：(空间复杂度O(n))
遍历一遍链表压栈，借助栈把链表倒序，然后依次比较“原链表元素”和“新栈中元素”，如果都相等则返回true，否则返回false。
这样简单粗暴，代码的主体包含在解法二中了，这里不列出了。
另外，这种解法的时间要求能不能通过Leetcode的测试，我没有试过，因为觉得没必要试。
解法二：(空间复杂度O(n/2))
解题思路：使用两个指针，fast和slow指针。
（1）fast指针每次走两步，slow指针每次走一步；
（2）fast指针走到链表末尾的时候，slow指针走到链表的中间位置结点（链表长度n为偶数）或中间位置的前一个结点（链表长度n为奇数）；
（1）——>（2）——>（3）——>（2）——>（1）
slow fast
（1）——>（2）——>（3）——>（3）——>（2） ——> （1）
slow (fast) 多走1步 fast
（3）slow直接到了中间，就可以将整个链表的后半部分压栈实现逆序，依次和前半部分比较，思路同解法一。
注：就是在这里，额外的时间复杂度减少了n/2，因为只需要将链表中一半的元素压栈。
其他的细节，代码里有详细注释。
/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ static const auto __ = []() { // turn off sync std::ios::sync_with_stdio(false); // untie in/out streams std::cin.tie(nullptr); return nullptr; }(); class Solution { public: bool isPalindrome(ListNode* head) { //额外空间复杂度O(n/2) /*使用两个指针，fast指针每次走两步，slow指针每次走一步；fast指针走到链表末尾的时候， slow指针走到链表的中间位置结点（链表长度n为偶数）或中间位置的前一个结点（链表长度n为奇数） */ //判空 if(head == NULL) return true; //单节点链表 if(head->next == NULL) return true; ListNode* fast = head; ListNode* slow = head;//指向第一个结点 //fast指针指向末尾结点，slow指针指向中间位置结点或中间位置的前一个结点 ////注意：这里的结束判断主要看fast!!! while(fast->next != NULL && fast->next->next != NULL ) { fast = fast->next->next; slow = slow->next; } //链表长度为偶数，fast指针最后多走一步到链表末尾 if(fast->next) fast = fast->next; stack<int> s; //将链表后半部分元素压栈，通过栈来实现逆序 while(slow->next) { s.push(slow->next->val); slow = slow->next; } //依次比较前半部分元素和逆序的后半部分元素 while(!s.empty()) { if(s.top() != head->val) return false; //前、后一起往后移动 s.pop(); head = head->next; } return true; } };
解法三：(进阶：空间复杂度O(1))
解题思路：解法三和解法二的区别在于，最后不使用栈来倒序链表后半部分的元素，而是选择直接本地操作(额外空间复杂度为O(1))，在原链表上将后半部分元素倒置（反转），比较完后得出结果后，再 还原链表，返回结果。
代码中有详细注释。
/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ static const auto __ = []() { // turn off sync std::ios::sync_with_stdio(false); // untie in/out streams std::cin.tie(nullptr); return nullptr; }(); class Solution { public: bool isPalindrome(ListNode* head) { //额外空间复杂度O(1) //判空 if(head == NULL) return true; //单节点链表 if(head->next == NULL) return true; //双节点链表 if(head->next->next == NULL) if(head->val == head->next->val) return true; else return false; ListNode* fast = head; ListNode* slow = head;//指向第一个结点 //fast指针指向末尾结点，slow指针指向中间位置结点或中间位置的前一个结点 ////注意：这里的结束判断主要看fast!!! while(fast->next != NULL && fast->next->next != NULL ) { fast = fast->next->next; slow = slow->next; } //链表长度为偶数，fast指针最后多走一步到链表末尾 if(fast->next) fast = fast->next; //-----区别在这里，元素不压栈，直接将链表后半部分元素逆序，比较完后得出结果后，再还原链表，返回结果--------// //---------------链表的后半部分元素“倒序”-------------------// ListNode* p = slow->next; ListNode* q = NULL; ListNode* cur = NULL; slow->next = NULL; while(p) { cur = p->next; p->next = q; q = p; p = cur; } //依次比较 前半部分元素 和 逆序的后半部分元素 while(1) { if(fast->val != head->val) { //链表复原 ListNode* m = q->next; ListNode* n = NULL; ListNode* cur2 = NULL; q->next = NULL; while(m){ cur2 = m->next; m->next = n; n = m; m = cur2; } slow->next = n; return false; } //前、后一起往后移动 fast = fast->next; head = head->next;
//--------在这里判断结束，是调试的结果----//
//针对这种情况：（3）——>(1)——>(2)——>(3),后半部分反转之后的链表是（3）——>(1)——>(3)——>(2)
// 如果使用while(head->next)作为结束，会少比较一次，也就是最后（1）和（2）不会比较到，从而出错 if(fast == NULL) break; } //链表复原 ListNode* m = q->next; ListNode* n = NULL; ListNode* cur2 = NULL; q->next = NULL; while(m){ cur2 = m->next; m->next = n; n = m; m = cur2; } slow->next = n; return true; } };
参考资料：
https://blog.csdn.net/blioo/article/details/62050967 单向链表反转（倒置）问题
以上是关于Leetcode 234. 回文链表(进阶)的主要内容，如果未能解决你的问题，请参考以下文章