LeetCode-java 7.整数反转(简单)

题7：类型：数组、数学

• 题目：给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。
  示例 1:
  输入: 123 --> 输出: 321
  示例 2:
  输入: -123 --> 输出: -321
  示例 3:
  输入: 120 --> 输出: 21
  注意:
  假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−231, 231 − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。

• 方法一 、暴力解法
  1. 将整数转为字符串，再转为字符串数组；
  2. 反向遍历并保存到新创建的字符串数组中；
  3. 将新字符串数组转换为字符串再转为整数。

注意：正负号的提取 和 判断是否超过32位。

class Solution {
    public int reverse(int x) {
        //整数类型的最小值绝对值 比 最大值绝对值 大1，会越界，所以不进行符号判断，直接返回
        if(Integer.MIN_VALUE == x || Integer.MAX_VALUE == x){
            return 0;
        }
        //判断符号
        int sign = x > 0 ? 1 : -1;
        //无论正负，都当成正数，负数在最后添加符号
        x = x < 0 ? -x : x;

        //1. 整数转字符串，再转字符数组
        String str = String.valueOf(x);
        char[] chars = str.toCharArray();
        //2.反向遍历字符串数组，将元素存储到新数组
        int len = chars.length;
        char[] array = new char[len];
        for(int i = len - 1; i >= 0; i--){
            array[len - 1- i] = chars[i];
        }
        //3.将新数组转换成字符串，再转换成整数输出，
        //Integer result = Integer.valueOf(String.valueOf(array))；
        long value = Long.valueOf(String.valueOf(array)); // 注意不能是Long类型接收
        boolean b = value > Integer.MAX_VALUE || value < Integer.MIN_VALUE;
        // 用long类型接收，判断是否越界，b为true则溢出，返回0
        int result = b ? 0 : (int)value;
        return  result * sign;
    }
}

小知识：1.判断32位的int类型是否越界，可以先用更大类型的long来接收，然后再做判断。2.首位不为0的问题，由valueOf函数解决了。

• 方法二 、交换解法
  1. 将整数转为字符串，再转为字符串数组；
  2. 在原数组基础上，设置两个索引，首位start 和 末位end，依次交换 start++ 和 end-- 相对应的字符；
  3. 将交换后的字符数组转换为字符串再转换为整数。

注意：若strat < end 则一直循环。该方法相对方法一，省下了创建新数组的空间。

class Solution {
    public int reverse(int x) {
        //整数类型的最小值绝对值 比 最大值绝对值 大1，会越界，所以不进行符号判断，直接返回
        if(Integer.MIN_VALUE == x || Integer.MAX_VALUE == x){
            return 0;
        }
        //判断符号
        int sign = x > 0 ? 1 : -1;
        //无论正负，都当成正数，负数在最后添加符号
        x = x < 0 ? -x : x;

        //1. 整数转字符串，再转字符数组
        String str = String.valueOf(x);
        char[] chars = str.toCharArray();
        //2.交换首位start和末位end数字
        int start = 0;
        int end = chars.length - 1;
        //3.循环操作，依次交换start++ 和 end--
        //当数组长度为偶数时，完成时标志位是start > end，为奇数时，start = end
        while (start < end){
            // 交换等距离元素
            char temp = chars[start];
            chars[start] = chars[end];
            chars[end] = temp;
            start ++;
            end --;
        }
        long value = Long.valueOf(String.valueOf(chars)); // 注意不能是Long类型接收
        boolean b = value > Integer.MAX_VALUE || value < Integer.MIN_VALUE;
        // 用long类型接收，判断是否越界，b为true则溢出，返回0
        int result = b ? 0 : (int)value;
        return  result * sign;
    }
}

• 方法三 、取模法
  1. 整数对10取余后拿到个位数字；
  2. 将整数除以10，再对10取余可以拿到倒数第二位数字，依次类推；
  3. 直到当前余数等于自身，可知已取到最高位；
  4. 将每次取到的余数依次乘10累加，即可得到反转后的整数。

注意：该方法符号处理与上两方法相同，在新整数补充最后一位前判断是否溢出，时间复杂度为O（n），空间复杂度为O（1）。

class Solution {
    public int reverse(int x) {
        //整数类型的最小值绝对值 比 最大值绝对值 大1，会越界，所以不进行符号判断，直接返回
        if(Integer.MIN_VALUE == x || Integer.MAX_VALUE == x){
            return 0;
        }
        //判断符号
        int sign = x > 0 ? 1 : -1;
        //无论正负，都当成正数，负数在最后添加符号
        x = x < 0 ? -x : x;

        //1. 拿个位数字，对10取模运算
        int result = 0;
        int last = 0; //末位
        //2.让每一个高位数字成为个位数字：除以10
        while ((last = x % 10) != x){  //已取到最高位
            //3.将每一位数字进行累加：上次累加结果*10 + 新数字
            result = result * 10 + last;
            x /= 10;
        }
        //最高位未处理，需要单独处理，并且补充最后一位之前判断是否溢出
        if(last != 0){ //此时last是最高位
            long re_temp = result; // 用re_temp保存最后结果，判断是否越界
            re_temp = re_temp * 10 + last;
            if(re_temp > Integer.MAX_VALUE || re_temp < Integer.MIN_VALUE){
                result = 0;
            }else {
                result = (int) re_temp;
            }
        }
        return  result * sign;
    }
}