使用 O(1) 额外空间查找链表中最长回文列表长度的 C++ 程序

简介

该程序是使用 C++ 编写的一个算法，用来查找单向链表中最长的回文列表的长度，同时要求空间复杂度为 O(1)。

算法思路

该算法的基本思路是从链表的中心开始，向两端遍历，判断是否为回文。我们可以通过快慢指针来找到链表的中心节点。然后，我们从中心开始，向两端遍历，比较节点的值是否相等，直到找到不相等的节点为止。同时，在这个过程中，我们需要记录下已经找到的最长回文列表的长度。最后，我们再从中心节点向两端遍历，找到最长的回文列表的长度。

代码实现

#include <iostream>
using namespace std;

struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};
 
class Solution {
public:
    int longestPalindrome(ListNode* head) {
        if (!head || !head->next) return 0;
        int ans = 0;
        ListNode* slow = head;
        ListNode* fast = head;
        while (fast && fast->next) {
            slow = slow->next;
            fast = fast->next->next;
        }
        ListNode* prev = NULL;
        while (slow) {
            ListNode* next = slow->next;
            slow->next = prev;
            prev = slow;
            slow = next;
        }
        ListNode* p1 = head;
        ListNode* p2 = prev;
        while (p1 && p2) {
            if (p1->val == p2->val) {
                ans += 2;
                p1 = p1->next;
                p2 = p2->next;
            } else {
                break;
            }
        }
        return ans + (p1 && p2 ? 1 : 0);
    }
};

int main() {
    Solution s;
    ListNode* head = new ListNode(1);
    head->next = new ListNode(2);
    head->next->next = new ListNode(3);
    head->next->next->next = new ListNode(2);
    head->next->next->next->next = new ListNode(1);
    cout << s.longestPalindrome(head) << endl;
    return 0;
}

代码解析

首先，我们检查链表是否为空，如果链表为空或者链表只有一个节点，那么回文列表的长度一定是 0。

然后，我们使用快慢指针来找到链表的中心节点。当快指针到达链表的尾部时，慢指针已经到达链表的中心节点。

接着，我们反转链表的后半部分，以便于从中心节点开始向两端遍历。我们通过记录已经找到的最长回文列表的长度来更新答案。

最后，我们再从中心节点向两端遍历寻找最长的回文列表长度。

总结

该算法的时间复杂度为 O(n)，空间复杂度为 O(1)。实现较为简单，适用于查找单向链表中最长回文列表的长度。