[LeetCode] #7 整数反转

给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。
如果反转后整数超过 32 位的有符号整数的范围 [−231,  231 − 1] ，就返回 0。
假设环境不允许存储 64 位整数（有符号或无符号）。

输入：x = 123

输出：321

我能想到的有两种思路。一是通过数学方式反转，二是通过字符串反转。

解法一：

先以123为例，思考其变化过程（其实就是加减乘除拼出答案，找规律再整理出来）

class Solution {
    public int reverse(int x) {
        
        int res = 0;//x = 123
        
        res*10//0
        x%10//3 
        res = res*10 + x%10;//0 + 3

        x = x/10;//12
        res*10//30
        x%10//2
        res = res*10 + x%10 //30 + 2
        
        x = x/10;//1
        res*10//320
        x%10//1
        res = res*10 + x%10 //320 + 1
        
        return res;

    }
}

提取公共部分转化为循环

class Solution {
    public int reverse(int x) {

        int res = 0;
        while(x != 0) {
            res = (res * 10) + (x % 10);
            x /= 10;
        }
        return res;

    }
}

提交后提示解答错误，看评论才知道还需要考虑反转后是否溢出（-231 <= x <= 231 - 1）

优化（参考评论）

class Solution {
    public int reverse(int x) {

        int res = 0;
        while(x != 0) {
            int tmp = res; // 保存计算之前的结果
            res = (res * 10) + (x % 10);
            x /= 10;
            // 将计算之后的结果 / 10，判断是否与计算之前相同，如果不同，证明发生溢出，返回0
            if (res / 10 != tmp) return 0; 
        }
        return res;

    }
}

解法二：

class Solution {
    public int reverse(int x) {

        String s = String.valueOf(x);
        String res = new StringBuffer(s).reverse().toString();
        if(x >= 0){
            return Long.parselong(res);
        } else {
            return -Long.parselong(res.substring(0,res.length()-1));
        }
        
    }
}

判断是否溢出

class Solution {
    public int reverse(int x) {

        String s = String.valueOf(x);
        String res = new StringBuffer(s).reverse().toString();
        if(x >= 0){
            //return Long.parselong(res);
            return Long.parseLong(res)<Integer.MIN_VALUE||Long.parseLong(res)>Integer.MAX_VALUE?0:(int)Long.parseLong(res);
        } else {
            //return -Long.parselong(res.substring(0,res.length()-1));
            return -Long.parseLong(res.substring(0,res.length()-1))<Integer.MIN_VALUE||-Long.parseLong(res.substring(0,res.length()-1))>Integer.MAX_VALUE?0:(int)-Long.parseLong(res.substring(0,res.length()-1));
        }
        
    }
}

后来我发现此种解法使用了Long，不符合题目规则，再一次学习别人的解法，利用try-catch捕获溢出异常（ 学到了！）

class Solution {
    public int reverse(int x) {

        try{
            String s = String.valueOf(x);
            String res = new StringBuffer(s).reverse().toString();
            if(x >= 0){
                return Integer.parseInt(res)<Integer.MIN_VALUE||Integer.parseInt(res)>Integer.MAX_VALUE?0:(int)Integer.parseInt(res);
            } else {
                return -Integer.parseInt(res.substring(0,res.length()-1))<Integer.MIN_VALUE||-Integer.parseInt(res.substring(0,res.length()-1))>Integer.MAX_VALUE?0:(int)-Integer.parseInt(res.substring(0,res.length()-1));
            }
        }catch(Exception e){
            return 0;
        }
        
    }
}

知识点：

int ：4个字节 32位

最小值：Integer.MIN_VALUE= -2147483648 （-2的31次方）

最大值：Integer.MAX_VALUE= 2147483647  （2的31次方-1）

long：8个字节 64位

最小值：Long.MIN_VALUE=-9223372036854775808 （-2的63次方）

最大值：Long.MAX_VALUE=9223372036854775807 （2的63次方-1）

String转int有两种方式

Integer.parseInt(str);

Integer.valueOf(str).intValue();

int转String有三种方式

num + “”;

String.valueOf(num);

Integer.toString(num);

Java实现字符串反转的三种方式

1. 利用 StringBuffer 或 StringBuilder 的 reverse 成员方法:

  // StringBuffer
  public static String reverse1(String str) {
    return new StringBuilder(str).reverse().toString();
  }

2. 利用 String 的 toCharArray 方法先将字符串转化为 char 类型数组，然后将各个字符进行重新拼接:

  // toCharArray
  public static String reverse2(String str) {
    char[] chars = str.toCharArray();
    String reverse = "";
    for (int i = chars.length - 1; i >= 0; i--) {
      reverse += chars[i];
    }
    return reverse;
  }

3. 利用 String 的 charAt 方法取出字符串中的各个字符:

  // charAt
  public static String reverse3(String str) {
    String reverse = "";
    int length = str.length();
    for (int i = 0; i < length; i++) {
      reverse = str.charAt(i) + reverse;
    }
    return reverse;
  }

总结：题目要求将某个东西变化成另一种东西，可以先以某个数据为例，摸索其变化过程，寻找规律，找到规律后，再看看能不能提取公共部分，做循环或者递归。