Leetcode 234. 回文链表(进阶)

Posted Timothy_Prayer

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Leetcode 234. 回文链表(进阶)相关的知识,希望对你有一定的参考价值。

题目描述:

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

示例 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 单向链表反转(倒置)问题

 






以上是关于Leetcode 234. 回文链表(进阶)的主要内容,如果未能解决你的问题,请参考以下文章

Leetcode链表回文链表(234)

LeetCode 234——回文链表

LeetCode234. 回文链表

Leetcode-234. 回文链表

leetcode 234. 回文链表 java

LeetCode 234——回文链表