Leetcode234.回文链表

回文链表判断:双指针巧解LeetCode 234
本文解析如何使用双指针法解决LeetCode中的回文链表问题,介绍O(n)时间复杂度和O(1)空间复杂度的实现思路,通过实例演示了如何判断链表是否回文。

Leetcode234.回文链表

题目地址

234.回文链表

题目详情

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

示例

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

说明

用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题

思路
可以借鉴判断数组是否是回文数的思想:双指针。扩展到链表中,则为快慢指针(fast-slow),即慢指针每次前进一个,快指针每次前进两个,初始化都在head。
主要思想:当fast指针下次移动到nil处(或遍历完链表)时,根据链表长度的奇偶性,可分为以下两种情况。

  1. 长度为奇数时:fast指针到达最后一个节点时,slow指针刚好到达中间节点,slow指针再走一步即可到达后半部分(根据回文数的性质,分为前半部分和后半部分)的第一个节点。
  2. 长度为偶数时:fast移动到nil处时,slow指针到达后半部分的第一个节点。

由上面两种情况分析可知:slow节点可以到达后半部分的第一个节点。这是如果我们可以知道前半部分的最后一个节点,那么就可以通过向后遍历slow指针和向前遍历指向前半部分的pre指针,通过比对二者的值,就可以判断该链表是否是回文数。
此时,问题就简化为找到指向前半部分最后一个节点的指针pre,并且可以向前遍历。解决这个问题的思路也很容易想到,那就是创建pre指针指向一个辅助的空节点,随着slow指针的遍历,翻转链表,直到fast指针指向最后一个节点或者指向nil。
实现代码

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func isPalindrome(head *ListNode) bool {
    if head == nil || head.Next == nil {
        return true
    }
    // 创建快慢指针和辅助指针
    slow, fast, pre :=  head, head, &ListNode{}
    pre = nil
    
    // 遍历链表,直到fast指针到最后一个节点或者指向nil
    for fast != nil && fast.Next != nil {
        fast = fast.Next.Next
        //  翻转链表
        slow, slow.Next, pre = slow.Next, pre, slow
    }
    // 如果fast指针指向最后一个节点,说明链表长度是奇数,需要进一步移动slow指针
    //  到后半部分的第一个节点,否则不用
    if fast != nil {
        slow = slow.Next 
    }
    // 分别向前和向后移动pre和slow指针,比较二者的值,判断是否是回文链表
    for pre != nil {
        if pre.Val != slow.Val {
            return false
        }
        pre, slow = pre.Next, slow.Next
    }

    return true
}

复杂度分析

时间复杂度:O(n),其中 n 为链表长度。

空间复杂度:O(1)。只需要常数的空间存放若干变量。
参考
Leetcode题解

LeetCode 234回文链表有多种解法,以下为你介绍几种常见的解法: ### 解法一:将链表复制到数组里再从两头比对 将链表元素复制到数组中,然后使用双指针从数组的两端向中间遍历,比较对应元素是否相等。如果在遍历过程中发现不相等的元素,则链表不是回文链表;如果遍历完整个数组都没有发现不相等的元素,则链表回文链表。 ```cpp #include <vector> class Solution { public: bool isPalindrome(ListNode* head) { std::vector<int> listvec; // 把链表中元素都插入数组 while (head != nullptr) { listvec.push_back(head->val); head = head->next; } // 一个迭代器从头,一个迭代器从尾 auto it_head = listvec.begin(); auto it_back = listvec.end() - 1; // 若迭代器相遇了则说明都检查完了,可以返回true while (it_back - it_head > 0) { // 检查到值不相等就返回false if ((*it_head++) != (*it_back--)) return false; } return true; } }; ``` ### 解法二:递归法 递归地遍历链表,同时使用一个指针从链表头开始比较。递归过程中,先递归到链表的末尾,然后在回溯的过程中与链表头指针指向的元素进行比较。 ```cpp class Solution { ListNode* frontPointer; public: bool recursivelyCheck(ListNode* currentNode) { if (currentNode != nullptr) { if (!recursivelyCheck(currentNode->next)) { return false; } if (currentNode->val != frontPointer->val) { return false; } frontPointer = frontPointer->next; } return true; } bool isPalindrome(ListNode* head) { frontPointer = head; return recursivelyCheck(head); } }; ``` ### 解法三:快慢指针 + 反转链表 使用快慢指针找到链表的中点,然后将链表的后半部分反转,最后比较前半部分和反转后的后半部分是否相等。 ```cpp 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; } private: 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; } }; ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值