234.回文链表

法一：截断+反转链表

改进：可反转后半段，还可快指针走两步，慢指针走一步来找到中点。

执行用时： 668 ms , 在所有 Python3 提交中击败了 77.21% 的用户
内存消耗： 32.6 MB , 在所有 Python3 提交中击败了77.55% 的用户

def isPalindrome( head: ListNode) -> bool:
    if head==None or head.next==None:
        return True
    #统计节点数目
    p=q=head
    cnt=1
    while q.next:
        q=q.next
        cnt+=1
    i=1
    p=head
    q=p.next
    #从中间截断
    if cnt % 2 != 0:
        q=q.next
    cnt=cnt//2
    while i<cnt:
        p=p.next
        q=q.next
        i+=1
    p.next = None
    #反转前1/2链表
    head=reverselist(head)
    p=head
    p=head
    #开始比较前后段链表
    while q!=None and p.val==q.val:
        p=p.next
        q=q.next
    if q:
        return False
    else:
        return True
    #反转链表函数
def reverselist(head:ListNode)->ListNode:
    if head==None or head.next==None:
        return head
    p=head.next
    head.next=None
    q=p.next
    while p:
        p.next=head
        head=p
        p=q
        if q:
            q=q.next
    return head

法二：递归

执行用时： 988 ms , 在所有 Python3 提交中击败了10.64% 的用户
内存消耗：139.7 MB , 在所有 Python3 提交中击败了5.03% 的用户

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def isPalindrome(self, head: ListNode) -> bool:
        self.frontnode=head#frontnode需加self.
        #退后一格的函数定义的使用
        def recurse(currentnode=head):#可选参数的默认值
            if currentnode:#递归的终止条件是currentnode==None
                if not recurse(currentnode.next):
                    return False
                if currentnode.val!=self.frontnode.val:
                    return False
                self.frontnode=self.frontnode.next
            return True
        return recurse()