给定一个 32 位有符号整数，将整数中的数字进行反转。

示例 1:

输入: 123
输出: 321

示例 2:

输入: -123
输出: -321

示例 3:

输入: 120
输出: 21

注意:

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

解法：

自己的思路（想太多），先把数字转化为字符串，字符串转化为字符数组，反转数组，再把数组转化为字符串，从而转为数字，再去判断是否在范围内。（做法错误）

class Solution {
    public int reverse(int x) {
        int flag=0;
        if(x<0){
            x=-x;
            flag=1;
        }
        String strX=String.valueOf(x);
        char[] strArray=strX.toCharArray();
        int start=0;
        int end=strArray.length-1;
        while(start<end){
            char temp=strArray[start];
            strArray[start++]=strArray[end];
            strArray[end--]=temp;
        }
        strX=String.valueOf(strArray);
        int y=Integer.parseInt(strX);
        if(flag==1){
            y=-y;
        }
        if(y>Integer.MIN_VALUE&&y<Integer.MAX_VALUE){
            return y;
        }else{
            return 0;
        }
     
    }
}

解法1：

leetcode上感觉思路上来说比较普遍的做法，思路是使用% / 来操作反转数字。(Integer 已经有MAX_VALUE、MIN_VALUE来表示最大值、最小值了)

class Solution {
    public int reverse(int x) {
        double res = 0;
        int sign = 1;
        
        if(x == 0)
            return 0;
        if(x < 0)
        {
            sign = -1;
            x = -1 * x;
        }
        
        while(x>0)
        {
            res = res * 10 + x % 10;
            x /= 10; 
        }
        res = sign * res ;
        if(res > Integer.MAX_VALUE || res < Integer.MIN_VALUE)
            return 0;
        
        return (int)res;
    }
}

解法2：

参考大佬的算法，算法虽比上面的耗时稍多，但代码很简洁，思路：将int数的个位提取出来进行缓存，然后每次循环向左移动一位，判断新组成的数是否越界。 如果没有越界，最后直接返回翻转后的数字，如果越界，新组成的数与原数字必定不一样，则除以10之后不再等于之前缓存的个位数。

class Solution {
    public int reverse(int x) {
        int i=0;
        while(x!=0){
            int n=i*10+x%10;
            x=x/10;
            if(n/10!=i){
                return 0;
            }  
            i=n;
        }
        return i;
    }
}