回文数

题目描述

给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。

回文数 是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

  • 例如，121 是回文，而 123 不是。

示例

1
2
3
输入：121 → 输出：true
输入：-121 → 输出：false
输入：10 → 输出：false

方法 1：字符串切片

实现步骤

要判断一个整数是否是回文数，可以通过以下步骤实现：

  • 负数处理 ：如果输入的整数 x 是负数，则它不可能是回文数，因为负号会让正序和倒序不同。
  • 反转数字比较 ：将整数反转后与原整数进行比较。如果两者相等，则说明它是回文数。

Python 实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Solution(object):
    def isPalindrome(self, x):
        """
        :type x: int
        :rtype: bool
        """
        # 如果 x 是负数，直接返回 False
        if x < 0:
            return False
        
        # 将整数转换为字符串
        str_x = str(x)
        
        # 判断字符串是否等于其反转后的结果
        return str_x == str_x[::-1]

逐行代码解析

1. 负数处理

1
2
if x < 0:
    return False

如果输入的整数 x 是负数，直接返回 False。

2. 整数转字符串

1
str_x = str(x)

为什么要转换为字符串？

  • 字符串支持切片操作（如 [::-1]），可以方便地获取字符串的反转结果。
  • 直接操作整数无法实现类似的反转操作。

3. 判断回文数

1
return str_x == str_x[::-1]

判断字符串 str_x 是否等于它的反转字符串 str_x[::-1]。

如果相等，则返回 True，表示 x 是回文数；否则返回 False。

1
2
3
4
5
6
7
str_x[::-1]是 Python 的切片操作，用于反转字符串。

切片语法 [start:end:step]：
start：起始索引（默认为第一个字符）。
end：结束索引（默认为最后一个字符之后）。
step：步长（正值表示正向取值，负值表示反向取值）。
[::-1] 表示从字符串的末尾开始，以步长 -1 反向取值，从而实现字符串的反转。

方法 2：不使用字符串（仅用数学运算）

思路

我们不能用 str(x) 把整数转成字符串。因此，需要用数学方式构造 “整数的倒序表示”，并且仅构造一半就能进行对比：

  • 如果数是回文，则前半部分和后半部分是一样的，我们可以转计后半部数字，和剩下的 x 进行比较即可。

实现步骤

  1. 如果 x < 0，是负数，不可能是回文
  2. 如果 x 最后一位是 0，但 x 不是 0，也不是回文
  3. 通过每次抽出 x 的最后一位，加到 reversed_half 的尾部，并把 x 去掉最后一位
  4. 当 reversed_half 大于或等于 x 时，表示已处理到中间，开始比较

示意图：1221 如何处理

1
2
3
4
5
6
7
8
x = 1221
reversed_half = 0

步骤：
取 1： reversed_half = 1， x = 122
取 2： reversed_half = 12， x = 12

比较: x == reversed_half → 是，返回 true

如果不是回文：示例 x = 1234

1
2
3
4
5
6
7
8
x = 1234
reversed_half = 0

取 4 → reversed_half = 4， x = 123
取 3 → reversed_half = 43， x = 12

比较: x = 12, reversed_half = 43 → 不等
返回 false

Python 实现

1
2
3
4
5
6
7
8
9
10
11
class Solution(object):
    def isPalindrome(self, x):
        if x < 0 or (x % 10 == 0 and x != 0):
            return False

        reversed_half = 0
        while x > reversed_half:
            reversed_half = reversed_half * 10 + x % 10
            x //= 10

        return x == reversed_half or x == reversed_half // 10

逐行代码解析

1. 提前处理 明显不是回文数 的情况

1
2
if x < 0 or (x % 10 == 0 and x != 0):
    return False
  • 负数和以 0 结尾的非 0 整数不能是回文

2. 创建一个变量用来保存 从后往前取出来的一半数字（反转的一半）

1
reversed_half = 0

3. 控制什么时候“反转了一半”

1
while x > reversed_half:

举例：

1
2
3
4
5
6
7
8
x = 1221
reversed_half = 0

# 第一次：拿出 1 → reversed_half = 1，x = 122
# 第二次：拿出 2 → reversed_half = 12，x = 12

此时：
x == reversed_half → 循环结束

4. 反转核心逻辑

我们要把整数 x 的最后一位一位“提取出来”，然后像搭积木一样把这些数字反转组合起来。

比如，我们有一个数 x = 1234，我们想把它从后往前反转得到：4321

1
2
reversed_half = reversed_half * 10 + x % 10
x //= 10

举例：

初始状态

1
2
x = 1234
reversed_half = 0

第一步循环

1
2
reversed_half = 0 * 10 + 1234 % 10 = 0 + 4 = 4
x = 1234 // 10 = 123

第二步循环

1
2
reversed_half = 4 * 10 + 123 % 10 = 40 + 3 = 43
x = 123 // 10 = 12

第三步循环

1
2
reversed_half = 43 * 10 + 12 % 10 = 430 + 2 = 432
x = 12 // 10 = 1

第四步循环

1
2
reversed_half = 432 * 10 + 1 % 10 = 4320 + 1 = 4321
x = 1 // 10 = 0

x % 10: 作用是取出数字的最后一位，例如 123 % 10 = 3

x //= 10: 整除 10，相当于x = x // 10

  • 作用是把数字“去掉最后一位,例如 123 // 10 = 12

reversed_half * 10: 作用是把上一轮的最后一位往前推进一格

5. 判断是不是回文

1
return x == reversed_half or x == reversed_half // 10

如果是偶数位数字，例如 1221：

  • 比较 x == reversed_half，就是 12 == 12

如果是奇数位数字，例如 12321：

  • 反转时 reversed_half 会多出一个中间数（比如 123）
  • 需要去掉中间数再比较：reversed_half // 10 就是去掉最后一位（3 → 去掉 3）