（leetCode）Reverse Integer—颠倒整数

题目如下：

给定一个范围为 32 位 int 的整数，将其颠倒。

例 1:

输入: 123
输出:  321

例 2:

输入: -123
输出: -321

例 3:

输入: 120
输出: 21

注意:

假设我们的环境只能处理 32 位 int 范围内的整数。根据这个假设，如果颠倒后的结果超过这个范围，则返回 0。

思路一：

1.将int转String,然后通过处理字符串反转的方式，得到初步字符串结果

2.考虑输入的int是否为负数

3.考虑是最终结果是否超出int的范围，因为超出范围，String 转int就会出错，偷懒方式可以加一个异常捕获

初步代码如下：

    public int reverse(int x) {
        
        Boolean flag = false;
        String xStr = String.valueOf(x);
        if (x < 0) {
            x = -x;
            flag = true;
            xStr = xStr.substring(1);
        }
        
        if (xStr == null || xStr.length() > 32) {
            return 0;
        }
        
        StringBuilder sb = new StringBuilder();
        for (int i = xStr.length(); i > 0; i--) {
            String temp = xStr.substring(i-1, i);
            sb.append(temp);
        }
        
        Long tempResult = Long.valueOf(sb.toString());
        if (tempResult > Math.pow(2,31) || -tempResult > Math.pow(2,31) + 1) {
            return 0;
        }
        if (flag) {
            if (-tempResult > Math.pow(2,32) + 2) {
                return 0;
            } else {
                return -tempResult.intValue();  
            }
            
        } else {
            if (tempResult > Math.pow(2,31)) {
                return 0;
            } else {
                return tempResult.intValue();
            }
        }
    }

在此基础上继续调整一下代码，下面的写法和上面的思路是一样的，只是避免了造轮子，不用写字符串反转的代码，使之看上去更优雅一点：

    public int reverse(int x) {
        String xStr = String.valueOf(x);
        StringBuilder sb = new StringBuilder(xStr);
        System.out.println(sb.toString());
        
        //使用StringBuilder 的 reverse()方法，反转字符串
        xStr = sb.reverse().toString();
        System.out.println(xStr);
        
        //判断x 是正数还是负数
        long resultLong = 0;
        if (xStr.endsWith("-")) {
            resultLong = -Long.valueOf(xStr.substring(0, xStr.length() - 1));
        } else {
            resultLong = Long.valueOf(xStr.substring(0, xStr.length()));
        }
         
        //判断颠倒后的数字是否已经超出了int的范围，如果超出返回0
        if (resultLong > Integer.MAX_VALUE || resultLong < Integer.MIN_VALUE）
 {
            return 0;
        }
        
        return (int)resultLong;
    }
    

以上两种效率都会比较低，在反转字符串的时候都是非常耗时的。

考虑到时反转的是int类型的，那是不是可以根据取商和取余的方式，每次都除以10，把商作为下次除法的被除数，并把余数作为结果的一部分从左到右显示，代码如下：

    public int reverse(int x) {
        
        long resultLong = 0;
        while(x != 0) {
            resultLong = resultLong * 10 + x%10;
            x /= 10;
        }
        
        if (resultLong > Integer.MAX_VALUE || resultLong < Integer.MIN_VALUE) {
            return 0;
        }

        return (int)resultLong;
        
    }

LeetCode最近才开始刷，刚开始压力还是有的，平时大多数都在写工作中的代码，对这种纯算法题目的经验比较少，不过，加油吧！!！