整数反转：巧妙处理溢出问题的算法详解-CSDN博客

整数反转：巧妙处理溢出问题的算法详解

🌺The Begin🌺点点关注，收藏不迷路🌺

1、问题描述

给定一个32位有符号整数 x，要求将其数字部分反转后返回。如果反转后的整数超出32位有符号整数范围 [-2³¹, 2³¹-1]，则返回0。注意： 环境不允许存储64位整数。

示例：

输入：123 → 输出：321
输入：-123 → 输出：-321
输入：120 → 输出：21
输入：0 → 输出：0

2、问题分析

整数反转看似简单，但核心难点在于如何处理溢出问题。32位整数范围是[-2147483648, 2147483647]，反转后的数字可能超出这个范围（如2147483649反转后为9463847412，超出范围）。

关键挑战：

反转过程中可能产生超出32位范围的中间结果
不能使用64位整数作为中间变量
需要高效处理正负数和边界值

3、算法思路：预判溢出法

我们采用预判溢出的策略，在每一步计算前检查是否会溢出：

统一处理为负数：利用负数范围比正数大的特性（负数范围[-2147483648,0]，正数范围[0,2147483647]）
逐位反转：通过取模和除法获取数字的每一位
预判溢出：在每次累加新数字前，检查：
- 如果当前结果 < INT_MIN/10，则下一步乘10后必然溢出
- 如果当前结果 == INT_MIN/10 且新数字 < INT_MIN%10，则下一步会溢出

4、C语言实现

#include <limits.h>

int reverse(int x) {
    // 特殊情况处理：0反转后还是0
    if (x == 0) return 0;
    
    // 判断是否为负数
    int isNegative = x < 0;
    
    // 统一转换为负数处理（避免正数转负数时的溢出）
    if (!isNegative) {
        x = -x;
    }
    
    int res = 0; // 存储反转结果（负数形式）
    
    while (x != 0) {
        int digit = x % 10; // 获取当前最后一位数字
        
        // 预判溢出：检查下一步计算是否会超出32位整数范围
        if (res < INT_MIN / 10 || 
            (res == INT_MIN / 10 && digit < INT_MIN % 10)) {
            return 0;
        }
        
        // 更新反转结果
        res = res * 10 + digit;
        x /= 10;
    }
    
    // 如果是正数，转换回正数形式
    return isNegative ? res : -res;
}

5、算法解析

5.1 关键步骤说明

统一负数处理：
```
if (!isNegative) {
    x = -x;
}
```
将正数转为负数，避免正数范围小于负数的问题
预判溢出条件：
```
if (res < INT_MIN / 10 || 
    (res == INT_MIN / 10 && digit < INT_MIN % 10))
```
- INT_MIN / 10 = -214748364
- INT_MIN % 10 = -8
- 如果当前结果小于-214748364，乘10后必溢出
- 如果当前结果等于-214748364且新数字<-8，乘10后加新数字会溢出
反转累加：
```
res = res * 10 + digit;
```
在确保不会溢出的前提下更新结果

5.2 处理流程示例（x=123）

转为负数：x = -123
循环处理：
- 第一轮：digit = -3 → res = -3
- 第二轮：digit = -2 → res = -3*10 + (-2) = -32
- 第三轮：digit = -1 → res = -32*10 + (-1) = -321
返回正数：-res = 321

5.3 边界情况处理

INT_MIN(-2147483648)：
- 反转后应为-8463847412
- 处理到倒数第二位时：res = -846384741
- 检查溢出：res < INT_MIN/10 (-214748364) → 返回0
2147483647：
- 反转后应为7463847412
- 处理到第二位时：res = -746384741
- 检查溢出：res < INT_MIN/10 → 返回0

6、复杂度分析

时间复杂度：O(log|x|)，取决于数字的位数
空间复杂度：O(1)，仅使用固定数量的变量

7、关键点总结

负数统一处理：巧妙利用负数范围更大的特性
预判溢出：在计算前检查，避免实际溢出
边界处理：正确处理INT_MIN和INT_MAX
高效运算：每次迭代处理一位数字

8、常见问题

为什么选择负数处理？
- 负数范围[-2147483648,0]比正数[0,2147483647]多一个数
- 避免对INT_MIN取绝对值时的溢出问题
如何处理末尾为0的情况？
- 取模运算会自然处理：120%10=0 → 反转后0成为首位 → 后续计算中自然消除
为什么通过率低？
- 大多数错误源于：
  - 未正确处理溢出
  - 边界值处理不当
  - 正负数分别处理导致逻辑复杂

9、扩展思考

如果允许使用64位整数：

long res = 0;
while (x) {
    res = res * 10 + x % 10;
    x /= 10;
}
return (res < INT_MIN || res > INT_MAX) ? 0 : res;

解法更简单，但不符合本题要求

如何输出反转过程？
- 可添加打印语句展示每一步的digit和res值
- 帮助理解算法执行过程
如何处理更大范围的数字？
- 可使用字符串存储数字
- 反转字符串后再转换回整数

面试提示：遇到此题应先讨论边界情况，再提出预判溢出的解法，展示严谨的思维过程。注意解释为什么选择负数处理而非正数处理。

掌握这种预判溢出的技巧，能有效解决各类整数运算中的边界问题！

在这里插入图片描述

🌺The End🌺点点关注，收藏不迷路🌺