一个简单却容易出错的算法题

给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。如果反转后整数超过 32 位的有符号整数的范围 [−2^31, 2^31 − 1] ，就返回 0。假设环境不允许存储 64 位整数（有符号或无符号）。
示例 1：
输入：x = 123
输出：321
示例 2：
输入：x = -123
输出：-321
示例 3：
输入：x = 120
输出：21
示例 4：
输入：x = 0
输出：0

解法一：

class Solution {
    public int reverse(int x) {
        int rev = 0;
        while(x != 0){
            int val = x%10;
            x/=10;
            rev = rev* 10 + val;
        }
        return (int)rev;
    }
}

当然这个题没有我们想的如此简单，前面的解法一并没有通过测试

为什么会出现这个问题呢？其实题目里讲了，int 的范围是[−2^31, 2^31 − 1] ,很明显 9646324351 超出了范围，造成了溢出。所以我们需要在输出前，判断是否溢出。

其中最终的一句代码：rev = rev* 10 + val;
我们对 temp = rev * 10 + val; 进⾏讨论：
首先我们知道 intMAX = 2147483647 , intMin = - 2147483648 。
对于⼤于 intMax 的讨论，此时 x ⼀定是正数，val也是正数。
如果 rev > intMax / 10 ，那么没的说，此时肯定溢出了。
如果 rev == intMax / 10 = 2147483647 / 10 = 214748364 ，此时 rev * 10 就是 2147483640 如果val大于7 ，那么就⼀定溢出了。
但是，如果假设 val 等于 8，那么意味着原数 x 是 8463847412了，输入的是 int ，而此时是溢出的状态，所以不可能输⼊，所以意味着 val 不可能⼤于 7 ，也就意味着 rev == intMax / 10 时不会造成溢出。
如果 rev < intMax / 10 ，意味着 rev 最⼤是 214748363 ， rev * 10 就是2147483630 , 此时再加上val，⼀定不会溢出。
对于⼩于 intMin 的讨论同理

改进解法一：

class Solution {
    public int reverse(int x) {
        int rev = 0;
        while(x != 0){
            int val = x%10;
            x/=10;
            if (rev > Integer.MAX_VALUE/10 ) return 0;
            if (rev < Integer.MIN_VALUE/10 ) return 0;
            rev = rev* 10 + val;
        }
        return rev;
    }
}

改进解法二：

class Solution {
    public int reverse(int x) {
        long rev = 0;
        while(x != 0){
            int val = x%10;
            x/=10;
            rev = rev* 10 + val;
        }
        if (rev > Integer.MAX_VALUE || rev < Integer.MIN_VALUE ) return 0;
        return (int)rev;
    }
}