力扣算法 - 整数反转

整数反转

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

• 示例 1:

输入: 1234
输出: 4321

• 示例 2:

输入: -1234
输出: -4321

• 示例 3:

输入: 120
输出: 21

注意:

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

解题思路

    /***
     *  思路
     *  1234
     *  第一步  0 * 10 + 4 = 4
     *  第二步  4 * 10 + 3 = 43
     *  第三步  43 * 10 + 2 = 432
     *  第四步  432 * 10 + 1 = 4321
     */
   
假设有1147483649这个数字，它是小于最大的32位整数2147483647的，但是将这个数字反转过来后就变成了9463847411，这就比最大的32位整数还要大了，这样的数字是没法存到int里面的，所以肯定要返回0(溢出了)。
可以判断反转前后数值是否相等解决问题

Java解题代码

// 常规解题
    public static int reverse1(int x) {
        int result = 0;
        while (x != 0) {
            int temp = x % 10;
            int newResult = result * 10 + temp;
            // 判断是否越界,如果越界前后两个值不会相等
            if ( ((newResult - temp) / 10 ) != result ) return 0;
            result = newResult;
            x = x /10;
        }
        return result;
    }
  
 // 简洁方法
 
     public static int reverse(int x) {
        long res = 0;
        while (x != 0) {
            res = res * 10 + x % 10;
            x = x / 10;
        }
        return (int) res == res ? (int) res : 0;
    }

Swift解题代码

  func reverse(_ x: Int) -> Int {
        var value: Int = x
        var result: Int = 0
        while value != 0 {
            let temp = value % 10
            let newResult = result * 10 + temp
            // 判断是否越界
            if newResult > Int32.max || newResult < Int32.min {
                return 0
            }
            result = newResult;
            value = value / 10;
        }
        return result;
    }