判断单链表是否为回文

• 利用栈和队列。时间复杂度O(n) 空间复杂度O(n)
  思路：遍历第一遍获取单链表的长度，再遍历一遍将前半部分压入栈中，后半部分入队。最后依次出栈和出队列，如果每一次出栈和出队的字符都相等则该单链表为回文。（注意奇数的中间既不入栈也不入队）

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

输入: 1->2->2->1 输出: True
'''

import sys


class Node:
    '''
    Node
    '''
    def __init__(self, num, next):
        self.data = num
        self.next = next


def create_linklist(numbers):
    '''
    create link_list
    :param numbers: list
    :return: Head Node of link_list
    '''
    head = Node(0, None)
    p = head
    for num in numbers:
        new_node = Node(num, None)
        p.next = new_node
        p = p.next
    return head


numbers = list(map(int, input().split()))  # input Link List
link_list = create_linklist(numbers)


# get the length of link_list
length = 0
p = link_list.next
while p != None:
    length += 1
    p = p.next

stack = []
queen = []
stack_len = length//2

p = link_list.next
count = 0
while p != None:
    count += 1
    if count <= stack_len:  # the left half of the link_list push to stack
        stack.append(p.data)
    elif count == stack_len+1 and (length%2 == 1):  # if length of link_list is odd , the middle number of link_list should be passed
        p = p.next
        continue
    else:   # the right half of the link_list push to queen
        queen.append(p.data)
    p = p.next

# pop stack and pop queen, respectively
flag = True
i = 0
j = len(stack)-1
while i < (length-stack_len) and j >= 0:
    if queen[i] != stack[j]:
        flag = False
        break
    i += 1
    j -= 1
if flag:
    sys.stdout.write("Yes")
else:
    sys.stdout.write("No")

• 快慢指针 时间复杂度O(n) 空间复杂度O(1)
  思路：利用快慢指针p和q，初始时均指向头结点。之后慢指针q每走一步，快指针走两步。当快指针走到链表的尾部时，慢指针所指向的结点即为中间结点。这时等于把链表劈成了两半，然后把后半部分链表逆置，最后依次比较前半部分链表和逆置后的链表即可。

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

输入: 1->2->2->1 输出: True
'''

import sys


class Node:
    '''
    Node
    '''
    def __init__(self, num, next):
        self.data = num
        self.next = next


def create_linklist(numbers):
    '''
    create link_list
    :param numbers: list
    :return: Head Node of link_list
    '''
    head = Node(0, None)
    p = head
    for num in numbers:
        new_node = Node(num, None)
        p.next = new_node
        p = p.next
    return head


numbers = list(map(int, input().split()))  # input Link List
link_list = create_linklist(numbers)


p = link_list  # faster pointer
q = link_list  # slower pointer

length_of_linkList = 0
while p!=None and p.next != None:
    q = q.next
    p = p.next.next
    length_of_linkList += 2
if p == None:  # length of link_list is odd
    length_of_linkList -= 1
right_half_list = q.next  # the first node of the right half link_list
q.next = None

# reverse the right half link_list
head_of_reverse_list = right_half_list
p = right_half_list.next
head_of_reverse_list.next = None
while p != None:
    temp = p.next
    p.next = head_of_reverse_list
    head_of_reverse_list = p
    p = temp
# compare the left half and the reversed right half

i = link_list.next
j = head_of_reverse_list
flag = True
while i!=None and j!=None:
    if i.data != j.data:
        flag = False
        break
    i = i.next
    j = j.next
if flag:
    sys.stdout.write("Yes")
else:
    sys.stdout.write("No")