力扣 7 整数反转

题目链接

https://leetcode.cn/problems/reverse-integer/

1、题目要求

给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。

如果反转后整数超过 32 位的有符号整数的范围 [−231,  231 − 1] ，就返回 0。

假设环境不允许存储 64 位整数（有符号或无符号）。（在 res 出来结果之前就需要判断，这里是一个大坑）

示例 1：
输入：x = 123
输出：321

示例 2：
输入：x = -123
输出：-321

示例 3：
输入：x = 120
输出：21

示例 4：
输入：x = 0
输出：0

2、思路分析

按照数学的方式以及按照字符串拼接的方式，可以出现两种解决方案，使用数学的时候，需要注意：如果是在 res 输出之前才进行判断的话，会出现数字溢出的情况需要注意。

在循环内部进行判断的时候，由于判断语句在 res * 10 之前，所以这里判断使用的是：res > Integer.MAX_VALUE / 10 , 没有加等号是因为，反转之后如果这个数字刚好是最大的 Integer 的时候，也是满足条件的，可以使用的；

这个题目理解起来很简单，但是溢出的问题需要仔细的斟酌；

在运行环境中，没有允许使用 64 位的变量进行数字的存储，所以只能在循环内部， res 没有出来之前就进行判断处理；

3、执行代码

使用数学的方式，取模运算

class Solution {
    public int reverse(int x) {
        int res = 0;
        while(x != 0) {
            //每次取末尾数字
            int tmp = x % 10;
            
            // 因为在下面结果需要再次乘以 10 所以这里大于 Integer.MAX_VALUE / 10
            // 由于反转之后可能就是最大以及最小的 Integer 整数，所以不能有等于号，相等也是符合条件的
            if (res > Integer.MAX_VALUE / 10 || res < Integer.MIN_VALUE / 10) {
                return 0;
            }
            
            res = res*10 + tmp;
            x /= 10;
        }
        
        return res;
    }
}

使用字符串拼接的办法 - 数字溢出 - 错误的做法，但是是一种思路

public static Integer reverse(Integer x) { 
    String num = String.valueOf(x);
    String res = "";
    
    // 将整个字符串进行反转，包括符号也反转，符号反转之后到最后了
    for (int i = 0; i < num.length(); i++) {
        res += num.charAt(num.length() - i -1);
    }
    
    // 处理符号问题
    if (res.charAt(res.length() - 1) == '-') {
        res = '-' + res;
        res = res.substring(0, res.length() - 1);
    }
    
    if (Integer.valueOf(res) > Integer.MAX_VALUE || Integer.valueOf(res) < Integer.MIN_VALUE) {
        return 0;
    }
    
    return Integer.parseInt(res);
    }

4、问题反思

在拼接字符串时候使用到的方法

str.chatAt() : 可以获取到字符串中的每一个字符
str.substring() : 可以获取到字符串的字串，可以用这个方法将字符的最后一个删除

String 转换为 Integer

Integer.valueOf(String)

Integer 转换为 String

String.valueOf(Integer)

4.1、时间复杂度以及空间复杂度

时间复杂度：O(n)

5、小结

解决整数反转的问题，有基于字符串拼接亿以及基于数学运算，重点是放置数字的溢出问题，本文关于字符串的溢出问题没有解决，解决了基于数学运算的溢出问题，在循环内部就进行判断，是一种比较好的处理方式。