判斷回文字符串、回文鏈表、回文數（python實現）

所謂回文字符串，就是正讀和反讀都一樣的字符串，比如“level”或者“noon”等等就是回文串。即是對稱結構

判斷回文字符串

方法一：

def is_palindrome(s):
    return True if s == s[::-1] else False

方法二：

def is_palindrome(s):
    length = len(s)
    if not length:  # 空字符串
        return True
    mid_index = length // 2  # 如果s長度為奇數則是中點，偶數則是后面那個中點
    index = 0
    status = True
    while index < mid_index:
        if s[index] == s[length - 1 - index]:
            index += 1
        else:
            status = False
            break
    return status

判斷回文鏈表

思路

1. 我們需要找到鏈表中點(快慢指針法)
2. 將鏈表后半段倒置逆序排序
3. 將前半段和后半段遍歷比較，判斷是否為回文鏈表，偶數情況，使用偶數定位中點策略，要確定是返回上中位數或下中位數

注意事項：

快慢指針定位中點時要區分奇偶情況，奇數情況，中點位置不需要矯正，偶數情況，使用偶數定位中點策略，要確定是返回上中位數或下中位數
如果是返回上中位數，后半部分串頭取next，如果是返回下中位數，后半部分串頭既是當前節點位置，但前半部分串尾要刪除掉當前節點

代碼

class Solution(object):
    def is_palindrome(self, head: ListNode) -> bool:
        if head is None:  # 空
            return False
        if head.next is None:  # 1個節點
            return True
        slow = fast = head

        # 1. 定中點
        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
        # 快慢指針定位中點，此時fast已到達鏈尾，如果長度為奇數，則slow到達中心點，長度為偶數，則slow到達下中位點

        # 2. 后半段倒置

        pre = None  # 倒置后的最后一個節點必為None,以此確定第三步遍歷時的終點
        cur = slow  # 當前要倒置的第一個節點
        nxt = slow.next  # 當前要倒置的節點的下一個節點

        while nxt:  # 只要沒有到達原鏈表的終點就一直進行倒置

            cur.next = pre  # 將當前節點的下一個節點指向"前"一個節點，進行倒置

            # 相鄰節點倒置完成后，向后整體偏移1個單位

            pre = cur
            cur = nxt
            nxt = cur.next

        # 當前cur是最后一個節點，需要和它前面的節點進行最后一次倒置，來完成整個后半段倒置

        cur.next = pre

        # 3. cur就是倒置完成后的后半段的頭節點,同時遍歷cur和head，如果遍歷完cur未出現不同的節點，則為回文鏈表

        while cur.next:
            if cur.val != head.val:
                return False
            cur = cur.next
            head = head.next
        # 此時cur為后半段的最后一個節點，還需要判斷此時的cur和head的值是否相同

        return cur.val == head.val

測試

# head =None
head = ListNode(1)
head.next = ListNode(2)
head.next.next = ListNode(1)

print(Solution().is_palindrome(head))

判斷回文數

思路

映入腦海的第一個想法是將數字轉換為字符串，並檢查字符串是否為回文。但是，這需要額外的非常量空間來創建問題描述中所不允許的字符串。

第二個想法是將數字本身反轉，然后將反轉后的數字與原始數字進行比較，如果它們是相同的，那么這個數字就是回文。 但是，如果反轉后的數字大於 int.MAX，我們將遇到整數溢出問題。

按照第二個想法，為了避免數字反轉可能導致的溢出問題，為什么不考慮只反轉int 數字的一半？畢竟，如果該數字是回文，其后半部分反轉后應該與原始數字的前半部分相同。

例如，輸入 1221，我們可以將數字“1221”的后半部分從“21”反轉為“12”，並將其與前半部分“12”進行比較，因為二者相同，我們得知數字 1221 是回文。

讓我們看看如何將這個想法轉化為一個算法。

算法

首先，我們應該處理一些臨界情況。所有負數都不可能是回文，例如：-123 不是回文，因為 - 不等於 3。所以我們可以對所有負數返回 false。

現在，讓我們來考慮如何反轉后半部分的數字。 對於數字 1221，如果執行 1221 % 10，我們將得到最后一位數字 1，要得到倒數第二位數字，我們可以先通過除以 10 把最后一位數字從 1221 中移除，1221 / 10 = 122，再求出上一步結果除以10的余數，122 % 10 = 2，就可以得到倒數第二位數字。如果我們把最后一位數字乘以10，再加上倒數第二位數字，1 * 10 + 2 = 12，就得到了我們想要的反轉后的數字。 如果繼續這個過程，我們將得到更多位數的反轉數字。

現在的問題是，我們如何知道反轉數字的位數已經達到原始數字位數的一半？

我們將原始數字除以 10，然后給反轉后的數字乘上 10，所以，當原始數字小於反轉后的數字時，就意味着我們已經處理了一半位數的數字。

代碼

class Solution(object):
    def is_palindrome(self, num: int) -> bool:

        # 當 x < 0 時，x 不是回文數
        # 如果數字的最后一位是 0，為了使該數字為回文，則其第一位數字也應該是 0
        # 只有 0 滿足這一屬性
        if num < 0 or (num % 10 == 0 and num != 0):
            return False

        reverted_num = 0

        while num > reverted_num:
            reverted_num = reverted_num * 10 + num % 10
            num /= 10

        # 當數字長度為奇數時，我們可以通過 revertedNumber / 10 去除處於中位的數字。
        #  例如，當輸入為12321時，在 while 循環的末尾我們可以得到 x = 12，revertedNumber = 123，
        #  由於處於中位的數字不影響回文（它總是與自己相等），所以我們可以簡單地將其去除。
        return num == reverted_num or num == reverted_num / 10

# 測試
print(Solution().is_palindrome(0))
print(Solution().is_palindrome(10))
print(Solution().is_palindrome(101))