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

给定一个链表，找出该链表中存在的最长回文链表的长度。
例子：

Input  : List = 2->3->7->3->2->12->24
Output : 5
The longest palindrome list is 2->3->7->3->2

Input  : List = 12->4->4->3->14
Output : 2
The longest palindrome list is 4->4

一个简单的解决方案可能是将链表内容复制到数组中，然后在数组中找到最长的回文子数组，但这种解决方案是不允许的，因为它需要额外的空间。
这个想法是基于迭代链表逆过程。我们遍历给定的链表，并从左侧开始一个接一个地反转链表的每个前缀。反转前缀后，我们找到从反转前缀开始的最长公共列表和反转前缀之后的列表。
下面是上述思想的实现。

Python

# Python program to find longest palindrome
# sublist in a list in O(1) time.
 
# Linked List node
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None
 
# function for counting the common elements
def countCommon(a, b) :
 
    count = 0
 
    # loop to count common in the list starting
    # from node a and b
    while ( a != None and b != None ) :
 
        # increment the count for same values
        if (a.data == b.data) :
            count = count + 1
        else:
            break
         
        a = a.next
        b = b.next
 
    return count
 
# Returns length of the longest palindrome
# sublist in given list
def maxPalindrome(head) :
 
    result = 0
    prev = None
    curr = head
 
    # loop till the end of the linked list
    while (curr != None) :
     
        # The sublist from head to current
        # reversed.
        next = curr.next
        curr.next = prev
 
        # check for odd length
        # palindrome by finding
        # longest common list elements
        # beginning from prev and
        # from next (We exclude curr)
        result = max(result,
                    2 * countCommon(prev, next) + 1)
 
        # check for even length palindrome
        # by finding longest common list elements
        # beginning from curr and from next
        result = max(result,
                    2 * countCommon(curr, next))
 
        # update prev and curr for next iteration
        prev = curr
        curr = next
     
    return result
 
# Utility function to create a new list node
def newNode(key) :
 
    temp = Node(0)
    temp.data = key
    temp.next = None
    return temp
 
# Driver code
 
# Let us create a linked lists to test
# the functions
# Created list is a: 2->4->3->4->2->15
head = newNode(2)
head.next = newNode(4)
head.next.next = newNode(3)
head.next.next.next = newNode(4)
head.next.next.next.next = newNode(2)
head.next.next.next.next.next = newNode(15)
 
print(maxPalindrome(head))
 
# This code is contributed by Arnab Kundu

输出 ：

5

时间复杂度： O(n ² )
请注意，上面的代码修改了给定的链表，如果不允许修改链表，则可能无法正常工作。然而，我们终于可以再做一次逆向来获取原始列表。有关更多详细信息，请参阅有关使用 O(1) 额外空间的链表中最长回文列表长度的完整文章！