回文单链表

LeetCode 234. 回文链表

特点:无法双向遍历

方法:

1. 单链表的后序遍历,利用递归产生的函数栈

   class Solution {
   public:
       ListNode* left;
       bool isPalindrome(ListNode* head) {
           left=head;
           return traverse(head);
       }
       bool traverse(ListNode* right){
           if(right==nullptr){
               return true;
           }
           bool res=traverse(right->next);
           res=res&&(right->val==left->val);//回溯,从后往前
           left=left->next;//从前往后
           return res;
       }
   };
   

   时间复杂度:O(N)

   空间复杂度:O(N)

2. 快慢指针+反转链表

class Solution {
public:
    bool isPalindrome(ListNode* head) {
        if(head==nullptr){
            return false;
        }
        ListNode* slow=head;//最终将移动到第n+1个节点
        ListNode* fast=head;//fast的移动速度是slow的两倍  最终将移动到2n+1个节点
        while((fast!=nullptr)&&(fast->next!=nullptr)){
            slow=slow->next;
            fast=fast->next->next;
        }
        if(fast!=nullptr){//如果链表的节点个数为奇数
            slow=slow->next;
        }
        ListNode* right=reverse(slow);
        ListNode* left=head;
        while(right!=nullptr){
            if(right->val==left->val){
                right=right->next;
                left=left->next;
            }else{
                return false;
            }
        }
        return true;
    }
    ListNode* reverse(ListNode* head){//反转以head为头结点的单链表
        ListNode* pre=nullptr;
        ListNode* cur=head;
        ListNode* nxt=head;
        while(cur!=nullptr){
            nxt=cur->next;
            cur->next=pre;
            pre=cur;
            cur=nxt;
        }
        return pre;
    }
};

时间复杂度:O(N)

空间复杂度:O(1)