回文链表-python

leetCode第234题 回文链表
链接：https://leetcode-cn.com/problems/palindrome-linked-list
给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false 。

示例 1：

输入：head = [1,2,2,1]
输出：true

示例2:

输入：head = [1,2]
输出：false

提示：

链表中节点数目在范围[1, 105] 内
0 <= Node.val <= 9

进阶：你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？

本题最简单的还是采用双指针的写法
在头部和尾部设立指针，一个向后移动，一个向前移动，但本题所给的是单链表而不是双链表，所以尾部指针不可能向前移动。
那么我们可以先将链表所有元素先存储下来，然后将新的链表进行一个反转，这样新链表的头指针就是我们需要的尾指针，并且能够将其移动。
反转链表可以参考第206题，传送门
但这种方法将浪费大量空间，因为我们需要存储一个数值一模一样的链表

## python3
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

class Solution:
    def isPalindrome(self, head: ListNode) -> bool:
        if head == None:
            return False
        if head.next == None:
            return True
        tail = head
        headA = ListNode()
        headA.val = head.val
        tailA = headA
        while tail.next != None:
            tail = tail.next
            temp = ListNode()
            temp.val = tail.val
            tailA.next = temp
            tailA = tailA.next
        headA = self.reverseList(headA)
        while head.next != None:
            if  head.val != headA.val:
                return False
            headA = headA.next
            head = head.next
        return True
    def reverseList(self, head: ListNode) -> ListNode:
        pre = None
        cur = head
        while cur != None:
            ne = cur.next
            cur.next = pre
            pre = cur
            cur = ne
        return pre

无论是在时间上还是在空间上效果都不理想

进阶中要求 我们用O(n) 时间复杂度和 O(1) 空间复杂度解决
那么我们应该对上述代码进行优化
-----------------------
上述代码的致命的缺陷是因为尾指针移动的需要而复制了一个一模一样的链表，而停止的条件是整个链表全都遍历完或者是有一处不相等。
其实我们知道回文链表是从中间开始对称的，停止的条件其实在遍历到链表的中间即可，由此来寻找灵感。
如果是回文链表的话，中间开始对称，我们不妨将链表一分为二，然后只将后一部分进行反转。因为反转会将原本链表的指向改变而丢失原链表的头指针，但链表被一分为二后，前一部分头指针和指向是被保留了，所以没有必要复制一个链表，在原链表的后一部分操作即可。
----------------------
接下来就是寻找可以将链表一分为二的结点
我们设立快慢指针，快指针一次走两步，满指针一次走一步，因为快指针是满指针速度的两倍，所以快指针遍历完时，满指针在链表的中间。
当链表为偶数时，快指针指向None,满指针在链表中间，前后一样长。

当链表为奇数时，快指针指向末尾元素，而慢指针刚还在正中间，这时不妨将慢指针向后移一位，再一分为二，使后续要反转的链表更短一些。

然后比较两个链表的元素是否相等来判断原链表是不是回文链表

## python3
class Solution:
    def isPalindrome(self, head: ListNode) -> bool:
        fast = head
        slow = head
        while fast != None and fast.next != None:
            fast = fast.next.next
            slow = slow.next
        if fast != None:
            slow = slow.next
        slow = self.reverseList(slow)
        fast = head
        while slow != None:
            if fast.val != slow.val:
                return False
            fast = fast.next
            slow = slow.next
        return True

    def reverseList(self, head: ListNode) -> ListNode:
        pre = None
        cur = head
        while cur != None:
            ne = cur.next
            cur.next = pre
            pre = cur
            cur = ne
        return pre