【LeetCode】Reverse Integer(整数反转)

这道题是LeetCode里的第7道题。

题目描述：

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

示例 1:

输入: 123
输出: 321

 示例 2:

输入: -123
输出: -321

示例 3:

输入: 120
输出: 21

注意:

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

首先，这是一道简单题，根据我多年的做题经验来看，这道题肯定有坑，绝对会有 INT_MAX_VALUE 和 INT_MIN_VALUE 的样例。所以我们肯定需要判断溢出。具体的过程在代码中，

• INT_MAX_VALUE = 2^31-1 = 2147483647
• INT_MIN_VALUE = -2^31 = -2147483648

提交代码：

class Solution {
    public int reverse(int x) {
        int res=0;
        //boolean flag=x<0?false:true;
        if(x>0){
            while(true){
                res+=x%10;
                x/=10;
                if(x==0)return res;
                if(res>214748364||res==214748364&&x%10>7)return 0;
                res*=10;
            }
        }else{
            while(true){
                res+=x%10;
                x/=10;
                if(x==0)return res;
                if(res<-214748364||res==-214748364&&x%10<-8)return 0;
                res*=10;
            }
        }
    }
}

才发现可以简化代码：

class Solution {
    public int reverse(int x) {
        int res=0;
        //boolean flag=x<0?false:true;
        while(true){
            res+=x%10;
            x/=10;
            if(x==0)return res;
            if(res>214748364||res==214748364&&x%10>7)return 0;
            if(res<-214748364||res==-214748364&&x%10<-8)return 0;
            res*=10;
        }
    }
}

提交结果：

个人总结：

虽然没有踩进本题的坑里，但是我被这道题秀了一波数学，负数的余数是负数。

StringBuffer 法：

class Solution {
    public int reverse(int x) {
        StringBuffer sb = new StringBuffer();
        String str = sb.append(String.valueOf(x < 0 ? x * -1 : x)).reverse().toString();
        try{
            return x < 0 ? Integer.parseInt(str) * -1 : Integer.parseInt(str);    
        }catch(Exception e){
            return 0;
        }
    }
}

运行时间：

其他代码：

class Solution {
    public int reverse(int x) {
        String s=String.valueOf(Math.abs(x));
        StringBuilder sb=new StringBuilder();
        for (int i=s.length()-1;i>=0;--i){
            sb.append(s.charAt(i));
        }
        try{
            return x>0?Integer.valueOf(sb.toString()):-Integer.valueOf(sb.toString());
        }catch (Exception e){
            return 0;
        }
    }
}

class Solution {
    public int reverse(int x) {
        char[] s = Integer.toString(x).toCharArray();
        int f = 0,b = s.length-1;
        String string = "";
        if (s[f] == '-') {
            string += '-';
            ++f;
        }
        while (b >= 0&& s[b] == '0') {
            --b;
        }
        while (f <= b) {
            string += s[b--];
        }
        if (string != "") {
            long num = Long.valueOf(string);
            if (num < (1<<31)-1 && num > -(1<<31)) {
                return (int)num;
            }
        }
        return 0;
    }
}

关于溢出的问题，最方便的解决方法是当溢出时直接抛出异常，然后在异常处理语句中返回 0，当然这个方法对 JDK 的版本有要求。具体读者可以自行搜索。