判断一个链表是否是回文结构 Python 版

题目：
判断一个链表是否是回文结构，如果是返回 True，否则返回 False
比如，给出一个链表为[2, 5, 12, 198, 12, 5, 2]，返回 True，
给定链表[2, 5, 12, 198, 12, 54, 20]，返回 False。

方法1：空间复杂度为 o(n)，使用一个栈，将链表中的数据全部push 到栈里，然后再迭代一遍链表，取出栈里的值逐个相互比较，如果不一样则说明不是回文链表。
代码：
在这个代码里，我使用了自己写的栈数据结构，方法都放在了另一篇blog 里面，队列和栈的数据结构 Python 版

    def is_palindrome1(head):
        '''
        判断一个链表是否是回文结构，如果是返回 True，否则返回 False
        方法1：时间复杂度o(n),空间复杂度o(n)
        '''
        if head == 0 or head.next == 0:
            return True
        p = head
        stack = Stack()  # 自定义的 Stack 数据结构，也可以使用python内置的 list来实现
        while p != 0:
            stack.push(p.value)
            p = p.next
        p = head
        while p != 0:
            if p.value != stack.pop():
                return False
            p = p.next
        return True

方法2：由于反向逆序链表的操作空间复杂度为O(1),所以，我将后半边的链表逆序，然后分别从链表的两头进行遍历，如果出现不一样的，就说明链表不是回文结构。这样，时间复杂度不变，空间复杂度为 o（1）。
代码：

    def is_palindrome2(self, head):
        '''
        判断一个链表是否是回文结构，如果是返回 True，否则返回 False
        方法2：时间复杂度o(n),空间复杂度o(1)，方法是将链表的右半边逆序反转一下，然后逐个比较，如果有不同，则返回错误
        '''
        p, length = head, 0
        while p != 0:
            length += 1
            p = p.next

        mid = (length+1) / 2 - 1
        p = head
        for _ in xrange(mid):
            p = p.next

        mid_node = p  # 获取中间节点
        tail = mid_node.next
        mid_node.next = 0

        pre = mid_node
        while tail != 0:
            p = tail.next
            tail.next = pre
            pre = tail
            tail = p

        p = head
        tail = pre
        #print "p.value", p.value, p.next.value, p.next.next.value, p.next.next.next
        #print "tail.value:", pre.value, pre.next.value, pre.next.next.value, pre.next.next.next.value
        while p != 0:
            #print "p.value:", p.value, "tail.value:", tail.value
            if p.value != pre.value:  # 分别从两头遍历链表，如果遍历到0，则说明已经遍历到头了。
                pre = 0
                while tail != 0:
                    next = tail.next
                    tail.next = pre
                    pre = tail
                    tail = next
                mid_node.next = pre.next
                return False
            else:
                p = p.next
                pre = pre.next
        pre = 0
        while tail != 0:
            next = tail.next
            tail.next = pre
            pre = tail
            tail = next
        mid_node.next = pre.next
        return True

体会：
核心就是，链表的逆序空间复杂度仅为3个变量。