7. 整数反转 - 力扣（LeetCode）

 基础知识要求：

Java：方法、数组、while循环、if判断、逻辑运算符、算术运算符

Python：方法、列表、while循环、if判断、逻辑运算符、算术运算符 、abs()正整数

题目： 

给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。

如果反转后整数超过 32 位的有符号整数的范围 [−231,  231 − 1] ，就返回 0。

假设环境不允许存储 64 位整数（有符号或无符号）。

示例 1：

输入：x = 123
输出：321

示例 2：

输入：x = -123
输出：-321

示例 3：

输入：x = 120
输出：21

示例 4：

输入：x = 0
输出：0

提示：

• -231 <= x <= 231 - 1

 Java代码示例：

public class Solution {  
  
    /**  
     * 反转一个32位有符号整数  
     *  
     * @param x 要反转的整数  
     * @return 反转后的整数，如果反转后超出范围则返回0  
     */  
    public int reverse(int x) {  
        int reversed = 0; // 反转后的整数，初始化为0  
  
        while (x != 0) { // 当x不为0时循环继续  
            int digit = x % 10; // 取出x的个位数字  
  
            // 检查反转后的数字乘以10加上下一个数字是否溢出  
            // 如果reversed已经大于Integer.MAX_VALUE / 10，或者  
            // reversed等于Integer.MAX_VALUE / 10且下一个数字digit大于7，则会发生溢出  
            if (reversed > Integer.MAX_VALUE / 10 || (reversed == Integer.MAX_VALUE / 10 && digit > 7)) {  
                return 0; // 溢出，返回0  
            }  
  
            // 检查反转后的数字是否小于Integer.MIN_VALUE  
            // 如果reversed已经小于Integer.MIN_VALUE / 10，或者  
            // reversed等于Integer.MIN_VALUE / 10且下一个数字digit小于-8（因为Integer.MIN_VALUE的个位数是8），则会发生溢出  
            if (reversed < Integer.MIN_VALUE / 10 || (reversed == Integer.MIN_VALUE / 10 && digit < -8)) {  
                return 0; // 溢出，返回0  
            }  
  
            reversed = reversed * 10 + digit; // 将digit添加到reversed的末尾  
            x /= 10; // 去掉已经处理的最低位  
        }  
  
        return reversed; // 返回反转后的整数  
    }  
  
    /**  
     * 主方法，用于测试reverse函数  
     *  
     * @param args 命令行参数  
     */  
    public static void main(String[] args) {  
        Solution solution = new Solution();  
        System.out.println(solution.reverse(123));    // 输出: 321  
        System.out.println(solution.reverse(-123));   // 输出: -321  
        System.out.println(solution.reverse(120));    // 输出: 21  
        System.out.println(solution.reverse(0));      // 输出: 0  
    }  
}

在这个Java实现中，我们使用了Integer.MAX_VALUE和Integer.MIN_VALUE来表示32位有符号整数的最大值和最小值。在每次迭代中，我们检查如果reversed乘以10再加上下一个数字是否会超过或低于整数的最大或最小值。如果会溢出，我们立即返回0。

注意：我们还需要处理负数的边界情况。由于整数反转后符号不变，因此在处理负数时，我们还需要检查反转后的数字是否会小于Integer.MIN_VALUE。但是，由于Integer.MIN_VALUE是一个负数的最小值（即-2^31），我们不能直接将其乘以10并加上一个数字来检查溢出，因为这会直接导致溢出。相反，我们需要检查如果reversed小于Integer.MIN_VALUE / 10或者reversed等于Integer.MIN_VALUE / 10但下一个数字小于-8（因为-Integer.MIN_VALUE % 10实际上是8），则会发生溢出。

Python代码示例：

class Solution:  
    def reverse(self, x: int) -> int:  
        sign = [1, -1][x < 0]  # 判断符号，如果 x 是负数，则 sign 为 -1  
        x = abs(x)  # 转为正数处理  
        reversed_x = 0  # 用来保存反转后的数字  
  
        while x > 0:  
            digit = x % 10  # 获取当前最低位的数字  
            reversed_x = reversed_x * 10 + digit  # 添加到反转数字的末尾  
            x //= 10  # 去掉已经处理的最低位  
  
            # 判断反转后的数字是否超出范围  
            if reversed_x > 2**31 - 1 or reversed_x < -2**31:  
                return 0  
  
        return reversed_x * sign  # 返回带有原始符号的反转数字  
  
# 示例测试  
solution = Solution()  
print(solution.reverse(123))    # 输出: 321  
print(solution.reverse(-123))   # 输出: -321  
print(solution.reverse(120))    # 输出: 21  
print(solution.reverse(0))      # 输出: 0

在这个解决方案中，我们首先确定整数的符号（正或负），然后将其绝对值用于反转操作。我们逐个处理整数的每一位数字，从最低位开始，并将其添加到 reversed_x 的末尾。在每次迭代中，我们都检查 reversed_x 是否会超出 32 位有符号整数的范围。如果是，我们立即返回 0。最后，我们将反转后的数字乘以原始符号，并返回结果。

请注意，我们在比较 reversed_x 时只与 2**31 - 1（即 2147483647）和 -2**31（即 -2147483648）进行比较，因为我们是在处理 32 位有符号整数，其中最高位是符号位。