題目描述：

請判斷一個連結串列是否為迴文連結串列。

示例 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 單向連結串列反轉（倒置）問題