LeetCode 每日一题 [7] 整数反转

LeetCode 整数反转 [简单]

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-integer

示例 1:

输入: 123
输出: 321

示例 2:

输入: -123
输出: -321
示例 3:

输入: 120

输出: 21

注意:

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

题目分析

解法1：

字符串是用来干嘛的？这题可以做，但是要注意，字符串反转的问题，如果超过了 int 所能表达的数值的范围，就不能继续进行了，所以需要 try-catch 一下 有异常就返回0,手动狗头

解法2：

那就是 一直 % 10，到了指定数据之后，在进行判断，具体的讲解请看链接https://leetcode-cn.com/problems/reverse-integer/solution/tu-jie-7-zheng-shu-fan-zhuan-by-wang_ni_ma/

解法3：

如果使用int会超出范围，那么long就不会了吧，先使用long存起来，然后再判断最后的结果是不是超出范围，超过范围就返回 0 ，没有超过范围，就是用 (int) res 强转。

解法4：

先使用long存起结果，然后使用 return (int) n == n ? (int) n : 0; 来返回结果，真的是太强了！ 我被楷模

代码实现

public class LeetCode_07_ReverseInteger {

    public static void main(String[] args) {
        System.out.println(reverse(98989898));
        System.out.println(reverse02(98989898));
        System.out.println(reverse03(98989898));
        System.out.println(reverse04(98989898));
        System.out.println("==================================");
        System.out.println(reverse(1147483649));
        System.out.println(reverse02(1147483649));
        System.out.println(reverse03(1147483649));
        System.out.println(reverse04(1147483649));
    }


    public static int reverse04(int x) {
        long n = 0;
        while (x != 0) {
            n = n * 10 + x % 10;
            x = x / 10;
        }
        return (int) n == n ? (int) n : 0;
    }

    public static int reverse03(int x) {
        long res = 0;
        int flag = -1;
        if (x < 0) {
            x = -x;
        } else {
            flag = 1;
        }
        while (x != 0) {
            res = res * 10 + x % 10;
            x /= 10;
        }
        res *= flag;
        if (res > Integer.MAX_VALUE || res < Integer.MIN_VALUE) {
            return 0;
        } else {
            return (int) res;
        }
    }

    public static int reverse02(int x) {
        int res = 0;
        while (x != 0) {
            int temp = x % 10;
            //判断是否 大于 最大32位整数
            if (res > 214748364 || (res == 214748364 && temp > 7)) {
                return 0;
            }
            //判断是否 小于 最小32位整数
            if (res < -214748364 || (res == -214748364 && temp < -8)) {
                return 0;
            }
            res = res * 10 + temp;
            x /= 10;
        }
        return res;
    }

    public static int reverse(int x) {
        //判断是不是正整数
        boolean flag = false;
        String temp = null;
        if (x == 0) {
            return 0;
        }
        if (x > 0) {
            flag = true;
            temp = String.valueOf(x);
        }
        if (x < 0) {
            temp = String.valueOf(-x);
        }
        StringBuilder sb = new StringBuilder(temp);
        String res = sb.reverse().toString();
        int targetRes = 0;
        try {
            targetRes = Integer.parseInt(res);
        } catch (NumberFormatException e) {
            return 0;
        }
        if (flag) {
            return targetRes;
        } else {
            return -targetRes;
        }
    }
}

测试

89898989
89898989
89898989
89898989
==================================
0
0
0
0