【30】234. Palindrome Linked List

234. Palindrome Linked List

Total Accepted: 86231

• Total Submissions: 271389
• Difficulty: Easy
• Contributors: Admin

Given a singly linked list, determine if it is a palindrome.

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
//用到stack存前半部的节点值
    bool isPalindrome(ListNode* head) {
        if(!head || !head -> next) return true;
        ListNode* slow = head, *fast = head;
        stack<int> s;
        s.push(head -> val);//别忘了要存进head的值
        while(fast -> next && fast -> next ->next){
            slow = slow -> next;
            fast = fast -> next -> next;
            s.push(slow -> val);
        }
        if(!fast -> next){
            s.pop();//如果链表是奇数个的话，只记到中点之前的值。因为每次比较，我们要从slow的后一个开始比。
        }
        while(slow -> next){
            slow = slow -> next;
            int tmp = s.top();
            s.pop();
            if(tmp != slow -> val){
                return false;
            }
        }
        return true;
    }
};

 

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

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool isPalindrome(ListNode* head) {
        if(!head || !head->next) return true;
        ListNode* slow = head, *fast = head;
        while(fast -> next && fast -> next -> next){
            slow = slow -> next;
            fast = fast -> next -> next;
        }
        ListNode* pre = head;
        ListNode* last = slow -> next;
        //因为follow up要求space是1 所以翻转后半部分 再从slow的next开始与pre的值进行比较
        while(last -> next){
            ListNode* tmp = last -> next;
            last -> next = tmp -> next;
            tmp -> next = slow -> next;
            slow -> next = tmp;//slow一直不变，其余节点不停往其后插入
        }
        while(slow -> next){
            slow = slow -> next;//从slow的next开始比较, 这时即可忽略当前的slow节点。反正是单个节点，可不比较；或者总数是偶数，即可一直比较。
            if(pre -> val != slow -> val) return false;
            pre = pre -> next;//别忘了pre也要往前走
        }
        return true;
    }
};