題目：
判斷一個連結串列是否是迴文結構，如果是返回 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個變數。