根据List输入，创建、打印、反转链表，并判断是否是回文链表

代码如下：

class Node:
    
    def __init__(self, val):
        self.val = val
        self.next = None
    
class LinkList:
    
    def __init__(self):
        self.head = None
        
    def create_linklist_from_list(self, input_list):
        input_list_len = len(input_list)
        if input_list_len == 0:
            return
        self.head = Node(input_list[0])
        cur = self.head
        for i in range(1, input_list_len):
            cur.next = Node(input_list[i])
            cur = cur.next
            
    def reverse_link_list(self):
        queue = []
        cur = self.head
        while cur:
            queue.append(cur.val)
            cur = cur.next
        queue.reverse()
        self.create_linklist_from_list(queue)
    
    def is_huiwen(self):
        tmp_link_list = LinkList()
        tmp_link_list.head = self.head
        pre_cur = tmp_link_list.head
        tmp_link_list.reverse_link_list()
        cur = tmp_link_list.head
        while cur:
            if cur.val != pre_cur.val:
                return False
            cur = cur.next
            pre_cur = pre_cur.next
        return True
    
    def __str__(self):
      cur = self.head
      string = ''
      while cur:
          string += (str(cur.val))
          string += (' --> ')
          cur = cur.next
      string += ('None')
      return string
    
                
input_list = [1,2,3,4,5]   
link_list = LinkList()  
link_list.create_linklist_from_list(input_list)      
print('原始链表: ', link_list) 

if link_list.is_huiwen():
    print(link_list, '是回文链')
else:
    print(link_list, '不是回文链') 
    
link_list.reverse_link_list()
print('反转后的链表: ', link_list)     
    

输出如下：

原始链表:  1 --> 2 --> 3 --> 4 --> 5 --> None
1 --> 2 --> 3 --> 4 --> 5 --> None 不是回文链
反转后的链表:  5 --> 4 --> 3 --> 2 --> 1 --> None

反转链表还有一种迭代方法：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        pre = None
        cur = head
        while cur:
            temp = cur.next  #先把next记录下来
            cur.next = pre   #反转
            pre = cur		#更新前置节点
            cur = temp		#更新当前节点
        return pre