力扣DAY24 | 热100 | 回文链表

前言

简单 √ 是反转链表的衍生题,很快写完了。不过没考虑到恢复链表结构的问题。

题目

给你一个单链表的头节点 head ,请你判断该链表是否为回文链表。如果是,返回 true ;否则,返回 false 。

示例 1:

输入:head = [1,2,2,1]
输出:true

示例 2:

输入:head = [1,2]
输出:false

提示:

  • 链表中节点数目在范围[1, 105] 内
  • 0 <= Node.val <= 9

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

思路

一开始想着把链表直接反转存储,然后同时遍历。但是考虑到题目要求的O(1)空间复杂度,想到可以只把前半部分,从中间开始向两边遍历。如果链表长度为奇数,跳过最中间的那个数。

我的题解

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    bool isPalindrome(ListNode* head) {
        
        if (!head || !head->next){
            return true;
        }
        
        //链表长度
        ListNode* node = head;
        int count = 1;
        while (node->next){
            node = node->next;
            count++;
        }

        //反转一半的链表,分奇偶两种情况
        int len = count / 2;
        ListNode* pre = nullptr;
        ListNode* cur = head;
        while (len--){
            ListNode* nextnode = cur->next;
            cur->next = pre;
            pre = cur;
            cur = nextnode;
        }
        ListNode* left = pre;
        ListNode* right = cur;
        if (count % 2 != 0){
            right = right->next;
        }

        //左右同时开始遍历
        while (left && right){
            if (left->val != right->val){
                return false;
            }
            left = left->next;
            right = right->next;
        }

        return true;
    }
};

官方题解

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

  1. 复制链表值到数组列表中。
  2. 使用双指针法判断是否为回文。
class Solution {
public:
    bool isPalindrome(ListNode* head) {
        vector<int> vals;
        while (head != nullptr) {
            vals.emplace_back(head->val);
            head = head->next;
        }
        for (int i = 0, j = (int)vals.size() - 1; i < j; ++i, --j) {
            if (vals[i] != vals[j]) {
                return false;
            }
        }
        return true;
    }
};

快慢指针

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

跟笔者思路差不多,不过多了还原链表结构的步骤

class Solution {
public:
    bool isPalindrome(ListNode* head) {
        if (head == nullptr) {
            return true;
        }

        // 找到前半部分链表的尾节点并反转后半部分链表
        ListNode* firstHalfEnd = endOfFirstHalf(head);
        ListNode* secondHalfStart = reverseList(firstHalfEnd->next);

        // 判断是否回文
        ListNode* p1 = head;
        ListNode* p2 = secondHalfStart;
        bool result = true;
        while (result && p2 != nullptr) {
            if (p1->val != p2->val) {
                result = false;
            }
            p1 = p1->next;
            p2 = p2->next;
        }        

        // 还原链表并返回结果
        firstHalfEnd->next = reverseList(secondHalfStart);
        return result;
    }

    ListNode* reverseList(ListNode* head) {
        ListNode* prev = nullptr;
        ListNode* curr = head;
        while (curr != nullptr) {
            ListNode* nextTemp = curr->next;
            curr->next = prev;
            prev = curr;
            curr = nextTemp;
        }
        return prev;
    }

    ListNode* endOfFirstHalf(ListNode* head) {
        ListNode* fast = head;
        ListNode* slow = head;
        while (fast->next != nullptr && fast->next->next != nullptr) {
            fast = fast->next->next;
            slow = slow->next;
        }
        return slow;
    }
};

心得

有了反转链表的基础,思路就很快想到了。一半反转,同时遍历即可。但是笔者没考虑到还原链表结构,这里暴露出笔者缺乏全局思考,代码拓展性的问题,纯粹是为了做题而做题,有点丢了本心,警醒!另外,反转链表还有个缺点就是需要锁定整个链表来解答,对于系统也不友好。最后,这里再加一个用栈的做法,比数组的做法更好,不过不是O(1)空间复杂度。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值