Reverse Integer（整数反转）

Given a 32-bit signed integer, reverse digits of an integer.

Example 1:

Input: 123
Output:  321

Example 2:

Input: -123
Output: -321

Example 3:

Input: 120
Output: 21

Note:

Assume we are dealing with an environment which could only hold integers within the 32-bit signed integer range. For the purpose of this problem, assume that your function returns 0 when the reversed integer overflows.

这道题是easy级别的，可能是刚刚接触的原因吧，在这道题上浪费了大量的时间，虽然也是做出来了，但也是很郁闷。我的代码如下（其实都是凑出来的）：

class Solution {
    public int reverse(int x) {
        if(x < (-2147483648) || x >(2147483647))
            return 0;
        if(x == 0)
            return 0;
        while((x % 10) == 0){
            x = x / 10;
        }
        String str = Integer.toString(x);
        if('-' == str.charAt(0)){
            String s = str.substring(1,str.length());
            String ss = reverse2(s);
           
            long res = Long.parseLong(ss);
            if(res > Integer.MAX_VALUE)
                return 0;
          
            return -(int)res;
        }
        else{
            String ss = reverse2(str);
             long res = Long.parseLong(ss);
            if(res > 2147483647)
                return 0;
            return (int)res;
        }
        
    }
    public String reverse2(String str){//字符串反转函数
        char[] arr = str.toCharArray();
        int len = arr.length;
        int start = 0,end = len-1;
        for(int i=0;i<(len/2);i++){
            char tmp = arr[start+i];
            arr[start+i] = arr[end-i];
            arr[end-i] = tmp;   
        }
        str = String.valueOf(arr);
        return str;
    }
}

我的想法：将整数转换为字符串，然后使用字符串反转即可。但是有一些细节必须要注意一下：

首先，判断输入的值是不是越界，但是怎么判断越界，我不清楚，直接找到了int的最大值、最小值，用于比较；

第二步，正数不话，负数的话，首先判断字符串的第一个位置是不是带有 ‘ - ’ 字符，若是，说明是负数，那么需要截取字符串，使用substring（n,m）函数（它左含右不含），然后进行反转，翻转后在进行 - 变为负数；

第三步：即第三个实例，如果末尾是0的话，反转过来后，处于前面的0要删除，这个怎么做的，一开始我还想反转过来之后再试图去掉，后来我这么做：对原来的数对10求%，如果能整除10，即意味这最后一位是0，那么就把它除以10；

但是，我还是忽略了两点：

第一：如果输入的数为0的时候，也属于边界条件吧！

第二：不仅输入的数需要判断越界，反转结束后，也得需要判断，反转的数是不是越界了。

总之，这道题思想不难，但是需要考虑多种情况，特别麻烦，尤其是溢出问题。一下几个问题需要注意并学习一下：

1、怎么解决数值越界问题；

2、字符串如何反转（也可以使用StringBuffer的append方法从后向前一位位的添加）；

3、使用long类型进行辅助操作；

4、如果不适用字符串的方法，如何进行；

5、整数反转和字符串反转有相同点，也有不同点。整数可以经过运算啊！

6、只要提到整数，我们就应该反应，它包括整数、负数和零。

总结：

1、int类型是32位，所以它可以表示的范围：-2^32  到   2^32 -1，也就是-2147483648 到 2147483647 ；使用Integer.MAX_VALUE 和 Integer.MIN_VALUE可以表示这两个数。

2、我的字符串反转代码，当时有一点很是费劲，i能不能等于len/2,即终结条件。

3、int与String之间的转换：Integer.ParseInt()字符转为int   String.valueOf() int转为字符

4、如果不适用字符串的话，使用取余和除相结合，一行代码总结：

res = 10 * res + x % 10;

然后，我重新使用这种方法写了一下：

public int reverse(int x) {
        if(x <= (Integer.MIN_VALUE) || x > (Integer.MAX_VALUE))
            return 0;
        if(x == 0)
            return 0;
        long res = 0;
        int num = Math.abs(x);
        while(num != 0){
            int ys = num % 10;
            res = res * 10 + ys;
            num = num / 10;
        }
         if(res > (Integer.MAX_VALUE))
            return 0;
        return (x > 0) ? (int)res : (-(int)res);
    }

也有几点需要注意：我的判断溢出方法是不对的！！！因为x本身就是int类型，所以，它不可能比那两个数要大或者要小，因此，在开始的时候，可以把x直接转换为long类型直接进行判断是可以的。其实看一下案例就知道，x == (Integer.MIN_VALUE)，其实就可以了。