[leetcode]Reverse Integer

Reverse Integer

 Reverse digits of an integer.

Example1: x = 123, return 321
Example2: x = -123, return -321

click to show spoilers.

Have you thought about this?

Here are some good questions to ask before coding. Bonus points for you if you have already thought through this!

If the integer's last digit is 0, what should the output be? ie, cases such as 10, 100.

Did you notice that the reversed integer might overflow? Assume the input is a 32-bit integer, then the reverse of 1000000003 overflows. How should you handle such cases?

Throw an exception? Good, but what if throwing an exception is not an option? You would then have to re-design the function (ie, add an extra parameter).

这道题出的挺好，但是对答案的处理非常不好，tip中显式的声明了溢出该怎么办，但是case中并未给出处理，说白了，case中压根就没有给出可能溢出的case。因此下面的代码可以过

public class Solution {
    public int reverse(int x) {
        boolean isPositive = x > 0?true:false;
        int tem = Math.abs(x);
        int result = 0;
        while(tem!=0){
            int temp = tem % 10;
            tem /= 10;
            result = 10 * result + temp;
        }
        return isPositive?result:-result;
    }
}

当然上面的代码，虽然过了，但是藏有很大的bug，下面这段代码对上面可能溢出的情况做出了处理，当返回结果溢出时，返回Integer.MAX_VALUE或者Integer.MIN_VALUE

public class Solution {
  public int reverse(int x) {
        int result = 0;
        boolean isNegative = x < 0 ? true : false; 
        int n = Math.abs(x);
        while(n!=0){
            int temp = n % 10;
            n /= 10;
            if(!isOverFlow(result, temp, isNegative) ){
                result = 10 * result + temp;
            }else{
                result = !isNegative ? Integer.MAX_VALUE:Integer.MIN_VALUE;
            }
        }
        return isNegative ? -result : result;
    }
    private boolean isOverFlow(int num,int tem, boolean isNegative){
        if(!isNegative){
            //Integer.MAX_VALUE = 2147483647
            if( (Integer.MAX_VALUE - tem) / 10 < num ) return true;
            return false;
        }else{
            //Integer.MIN_VALUE = -2147483648
            if( (Integer.MIN_VALUE + tem) / 10 > -num ) return true;
            return false;
        }
    }
}

 第二遍：

跟上面的代码差不多，只是做了简单的优化：

public class Solution {
    public int reverse(int x) {
        boolean isNegative = x < 0;
        int res = 0;
        x = Math.abs(x);
        while(x != 0){
            int tem = x % 10;
            x /= 10;
            if( isOverFlow(res,isNegative) ) return isNegative ? Integer.MIN_VALUE : Integer.MAX_VALUE;
            res = res * 10 + tem;
        }
        return isNegative ? -res : res;
    }
    private boolean isOverFlow(int tem, boolean isNegative){
        return tem > (isNegative ? -(Integer.MIN_VALUE / 10) : Integer.MAX_VALUE / 10);
    }
}

FYI