Leetcode 7.整数反转

给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。

示例 1:

输入: 123
输出: 321

示例 2:

输入: -123
输出: -321

示例 3:

输入: 120
输出: 21

注意:

假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−2^31, 2^31 − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-integer
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

我的cpp解法(不符合题意！！):

class Solution {
public:
    int reverse(int x) {
        if(x == (-1) * pow(2, 31) || x == 0)
        {//判断越界
            return 0;
        }

        string num; //存储x的反转的绝对值
        int flag; //若flag == 0, x为正数;

        int y;
        if(x < 0)
        {
            flag = 1;
            y = x * (-1);
        }
        else
        {
            flag = 0;
            y = x;
        }

        int i = 0;
        while(y != 0)
        {
            num[i] = y % 10;
            i++;
            y /= 10;
        }

        int j;
        for(j = 0; j <= i-1; j++)
        {
            if(num[j] == '0')
            {
                continue;
            }
            else
            {
                break;
            }
        }

        long ans = num[j];

        for(int k = j+1; k <= i-1; k++)
        {
            ans *= 10;
            //前几次提交时发现部分测试数据在此处的计算过程中也会出现越界情况，所以把ans变量的数据类型由int改为long, 并且在此处判断一次越界
            if(ans > pow(2, 31))
            {
                return 0;
            }
            ans += num[k];
        }

        if(flag == 1)
        {
            ans *= -1;
        }
		//函数的返回值为int型，此处将long型的ans显式转换为int型
        return (int)ans;

    }
};

优化思路：

• 本题如果不考虑溢出问题，是非常简单的。解决溢出问题有两个思路，第一个思路是通过字符串转换加try
  catch的方式来解决，第二个思路就是通过数学计算来解决。
• 由于字符串转换的效率较低且使用较多库函数，所以解题方案不考虑该方法，而是通过数学计算来解决。
• 通过循环将数字x的每一位拆开，在计算新值时每一步都判断是否溢出。

根据题意可知不能用long存储最终结果，而且有些数字可能是合法范围内的数字，但是反转过来就超过范围了。
假设有1147483649这个数字，它是小于最大的32位整数2147483647的，但是将这个数字反转过来后就变成了9463847411，这就比最大的32位整数还要大了，这样的数字是没法存到int里面的，所以肯定要返回0(溢出了)。甚至，我们还需要提前判断
上图中，绿色的是最大的32位整数。
第二排数字中，橘子的是5，它是大于上面同位置的4，这就意味着5后跟任何数字，都会比最大32为整数都大。
所以，我们到【最大数的1/10】时，就要开始判断了
如果计算过程中数字大于 214748364那后面就不用再判断了，肯定溢出了。
如果计算过程中数字等于 214748364呢，这对应到上图中第三、第四、第五排的数字，就要跟最大数的末尾数字比较，如果这个数字比7还大，说明溢出了。

对于负数也是一样的：

上图中绿色部分是最小的32位整数，同样是在【最小数的 1/10】时开始判断。
如果在计算过程中数字小于 -214748364说明溢出了
如果在计算过程中数字等于 -214748364，还需要跟最小数的末尾比较，即看它是否小于8。

作者：wang_ni_ma
链接：https://leetcode-cn.com/problems/reverse-integer/solution/tu-jie-7-zheng-shu-fan-zhuan-by-wang_ni_ma/
来源：力扣（LeetCode） 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

所以综上所述：

• 溢出条件有两个，一个是大于整数最大值MAX_VALUE，另一个是小于整数最小值MIN_VALUE，设当前计算结果为ans，下一位为pop。
• 从ans * 10 + pop > MAX_VALUE这个溢出条件来看
  • 当出现 ans > MAX_VALUE / 10 且还有pop需要添加 时，则一定溢出
  • 当出现 ans == MAX_VALUE / 10 且 pop > 7 时，则一定溢出，7是2^31 - 1的个位数
• 从ans * 10 + pop < MIN_VALUE这个溢出条件来看
  • 当出现 ans < MIN_VALUE / 10 且还有pop需要添加 时，则一定溢出
  • 当出现 ans == MIN_VALUE / 10 且 pop < -8时，则一定溢出，8是-2^31的个位数

作者：guanpengchn
链接：https://leetcode-cn.com/problems/reverse-integer/solution/hua-jie-suan-fa-7-zheng-shu-fan-zhuan-by-guanpengc/
来源：力扣（LeetCode） 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

优化题解:
Java解法

class Solution {
    public int reverse(int x) {
        int ans = 0;
        while (x != 0) {
            int pop = x % 10;
            if (ans > Integer.MAX_VALUE / 10 || (ans == Integer.MAX_VALUE / 10 && pop > 7)) 
                return 0;
            if (ans < Integer.MIN_VALUE / 10 || (ans == Integer.MIN_VALUE / 10 && pop < -8)) 
                return 0;
            ans = ans * 10 + pop;
            x /= 10;
        }
        return ans;
    }
}