###234. Palindrome Linked List

题目:
<https://leetcode.com/problems/palindrome-linked-list/>


难度:
Easy

这道题我花了很久的时间


思路是：“先翻转整个链表，然后和之前的链表比较”

但是一直不能AC，然后去谷歌了，然后debug的过程发现原来的linked list也不存在了.


“先翻转整个链表，然后和之前的链表比较”听起来是可行的，但是当你“翻转了整个链表”以后，“之前的链表”已经不存在了啊。这时候的head其实是指向翻转后的链表的最后一个元素，所以这段代码的本质是：“比较链表的第1个和最后1个元素是否相同”。


如果用这个思路的话，你就必须创建一个原始链表的备份才行。但与其那样做，还不如干脆把List中元素拷贝到数组中算了，因为都是O（N）内存，后者实现起来还简单快捷一些。


所以艰难的第一个AC办法：


```
class Solution(object):
    def isPalindrome(self, head):
        """
        :type head: ListNode
        :rtype: bool
        """
        if head == None or head.next == None:
            return True
        
        cur = head
        stack = []
        while cur:
            stack.append(cur.val)
            cur = cur.next
        
        while head and stack:
            if head.val != stack.pop():
                return False
            else:
                head = head.next
        return True
```

这道题并不能算Easy吧：

思路二：
找到中间的节点，把linked list拆成两个部分，后半部分linkedlist reverse，然后比较两个linked list值是否相同，看例子：


```
1 -> 3 -> 1 拆成 1 和 1

1 -> 3 -> 5 ->5 -> 3 -> 1 拆成 1-> 3 -> 5 和 5 -> 3 -> 1

```

然后用这个思路的时候还有一个问题，就是特别简单的Python递归可能建议不用递归，因为递归反倒可能recursion到极限，用loop可能更顺.

第二个AC之法，因为懒，所以老用之前用过的代码：

这个速度也是慢的厉害



```
class Solution(object):
    def isPalindrome(self, head):
        """
        :type head: ListNode
        :rtype: bool
        """
        if head == None or head.next == None:
            return True
        
        mid = self.findMid(head)
        mid = self.reverseList(mid)
        
        while head and mid:
            if head.val != mid.val:
                return False
            else:
                head = head.next
                mid = mid.next
        return True
        
        
        
    def findMid(self, head):
        if head == None:
            return None
        else:
            slow = head
            fast = head
        
            while fast.next and fast.next.next:
                slow = slow.next
                fast = fast.next.next
        
            print(slow.val)
            return slow.next
    
    def reverseList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        prev = None 
        cur = head
        while(cur):
            nxt = cur.next
            cur.next = prev
            prev = cur
            cur = nxt
        return prev
```

然后看了一下，如果把这三块写在一起，会轻松一些，AC速度快很多
