东莞公司网站广告联盟网站建设

234. 回文链表 - 力扣（LeetCode）https://leetcode.cn/problems/palindrome-linked-list/description/?envType=study-plan-v2&envId=top-100-liked

常规法

数组是连续的存储空间，可以根据索引到达任意位置，链表只能一个个的顺着指向访问元素。最常规的方法就是将链表的元素用额外的空间存储到列表里面，看这个列表是否是回文。

//c++
/*** 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* a=head;vector<int> b;while(a){b.emplace_back(a->val);a=a->next;}for(int i=b.size()-1;i>-1;i--){if(head->val!=b[i])    return false;head=head->next;}return true;}
};#python
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:def isPalindrome(self, head: Optional[ListNode]) -> bool:a=[]while head:a.append(head.val)head=head.nextreturn a==a[::-1]

递归法

以一个全局变量记录头指针，然后递归到链表的最后，根据递归的性质不断将头指针的下一个元素与递归的上一层进行比较。

//c++
/*** 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 {ListNode* frontPointer;
public:bool a(ListNode* b){if(b!=nullptr){if(!a(b->next))    return false;if(b->val!=frontPointer->val)   return false;frontPointer=frontPointer->next;}return true;}bool isPalindrome(ListNode* head) {frontPointer=head;return a(head);}
};#python
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:def isPalindrome(self, head: Optional[ListNode]) -> bool:self.front_pointer=headdef a(b=head):if b is not None:if not a(b.next):return Falseif self.front_pointer.val!=b.val:return Falseself.front_pointer=self.front_pointer.nextreturn Truereturn a()

改变链表

不用额外的空间，但又想判断链表，所以一次走一步，一次走两步找到中间位置（挺巧妙的），然后将中间位置往后的链表反转，直接访问元素进行判断，最后要注意恢复链表。

//c++
/*** 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* a(ListNode* b){ListNode* pre=nullptr;while(b){ListNode* nex=b->next;b->next=pre;pre=b;b=nex;}return pre;}bool isPalindrome(ListNode* head) {ListNode* f=head;ListNode* s=head;while(f->next&&f->next->next){f=f->next->next;s=s->next;}s=a(s);f=s;bool ans=true;while(head&&s){if(head->val!=s->val)   ans=false;head=head->next;s=s->next;}a(f);return ans;}
};#python
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:def isPalindrome(self, head: Optional[ListNode]) -> bool:if not head:return Truef=heads=headwhile f.next and f.next.next:f=f.next.nexts=s.nexta=self.reverse(s)b=aans=Truewhile head and a:if head.val!=a.val:ans=Falsehead=head.nexta=a.nextself.reverse(b)return ansdef reverse(self,head):pre=Nonec=headwhile c:n=c.nextc.next=prepre=c c=nreturn pre