LeetCode 234.回文链表（C++实现）

一、题目描述

请判断一个链表是否为回文链表。

示例 1:

输入: 1->2
输出: false

示例 2:

输入: 1->2->2->1
输出: true

进阶：
你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？

 

二、思路

 

方法一：将值复制到数组中后用双指针法

确定数组列表是否为回文很简单，我们可以使用双指针法来比较两端的元素，并向中间移动。一个指针从起点向中间移动，另一个指针从终点向中间移动。这需要 O(n) 的时间，因为访问每个元素的时间是 O(1)，而有 n 个元素要访问。

然后，直接在链表上操作并不简单，因为不论是正向访问还是反向访问都不是 O(1)。而将链表的值复制到数组列表中是 O(n)，因此最简单的方法就是将链表的值复制到数组列表中，再使用双指针法判断。

第一步，我们需要遍历链表将值复制到数组列表中。 第二步，我们在起点放置一个指针，在结尾放置一个指针，每一次迭代判断两个指针指向的元素是否相同，若不同，返回 false；相同则将两个指针向内移动，并继续判断，直到相遇。

复杂度分析

• 时间复杂度：O(n)，其中n 指的是链表的元素个数。

第一步： 遍历链表并将值复制到数组中，O(n)。

第二步：双指针判断是否为回文，执行了 O(n/2) 次的判断，即 O(n)。

总的时间复杂度：O(2n) = O(n)。

• 空间复杂度：O(n)，其中 n 指的是链表的元素个数，我们使用了一个数组列表存放链表的元素值。

 

方法二：

避免使用 O(n) 额外空间的方法就是改变输入。

我们可以将链表的后半部分反转（修改链表结构），然后将前半部分和后半部分进行比较。比较完成后我们应该将链表恢复原样。虽然不需要恢复也能通过测试用例，因为使用该函数的人不希望链表结构被更改。

我们可以分为以下几个步骤：

1. 找到前半部分链表的尾节点。
2. 反转后半部分链表。
3. 判断是否为回文。
4. 恢复链表。
5. 返回结果。

执行步骤一，我们可以计算链表节点的数量，然后遍历链表找到前半部分的尾节点。

或者可以使用快慢指针在一次遍历中找到：慢指针一次走一步，快指针一次走两步，快慢指针同时出发。当快指针移动到链表的末尾时，慢指针到链表的中间。通过慢指针将链表分为两部分。

若链表有奇数个节点，则中间的节点应该看作是前半部分。

步骤二可以使用在反向链表问题中找到解决方法来反转链表的后半部分。

步骤三比较两个部分的值，当后半部分到达末尾则比较完成，可以忽略计数情况中的中间节点。

步骤四与步骤二使用的函数相同，再反转一次恢复链表本身。

 

 

 

三、实现

 

方法一：

/**
 * 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 == NULL || head->next == NULL) return true;
        vector<int> val;
        ListNode *tmp =head;
        while(tmp){
            val.push_back(tmp->val);
            tmp = tmp->next;
        }
        int m = 0, n = val.size() - 1;
        while(m < n){
            if(val[m] != val[n]) return false;
            m++;
            n--;
        }
        return true;
    }
};

 

方法二：

class Solution {
public:
    bool isPalindrome(ListNode* head) {
        if(head == NULL || head->next == NULL) return true;
        
        //利用双指针将前后链表拆分
        ListNode *fast = head,*slow = head;
        while(fast->next && fast->next->next){   //此处判断条件至关重要，若改为 fast && fast->next,则得到的slow直接就是后半链表的头，而得不到前半尾。
            fast = fast->next->next;
            slow = slow->next;
        }
        ListNode *fristEnd = slow; //前半部分链表的尾，链表长度为奇数时，slow指向链表中间；
                                   //链表长度为偶数时，slow指向上一半的结束，无论怎样，下一半链表                                    //的头为 slow->next

        //反转后半部分的链表
        ListNode *secondBeginbe = fristEnd->next; //反转前，后半部分链表的头
        ListNode *next = NULL;
        ListNode *pre = NULL;
        while(secondBeginbe){
            next = secondBeginbe->next;
            secondBeginbe->next = pre;
            pre = secondBeginbe;
            secondBeginbe = next;
        }

        //比较前半部分和后半部分的链表
        ListNode *fristBegin = head;      //前半部分链表的头
        ListNode *secondBeginnow = pre;   //反转后，后半部分链表的头
        
        bool result = true;
        while(fristBegin && secondBeginnow){
            if(secondBeginnow->val != fristBegin->val) result = false;
            secondBeginnow = secondBeginnow->next;
            fristBegin = fristBegin->next;
        }

        //恢复链表
        next = NULL,pre = NULL;
        while(secondBeginnow){
            next = secondBeginnow->next;
            secondBeginnow->next = pre;
            pre = secondBeginnow;
            secondBeginnow = next;
        }
        fristEnd->next = pre;
        return result;
    }
};