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

题7：类型：数组、数学

题目：给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。

示例 1:

输入: 123 --> 输出: 321

示例 2:

输入: -123 --> 输出: -321

示例 3:

输入: 120 --> 输出: 21

注意:

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

方法一 、暴力解法

将整数转为字符串，再转为字符串数组；

反向遍历并保存到新创建的字符串数组中；

将新字符串数组转换为字符串再转为整数。

注意：正负号的提取 和 判断是否超过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函数解决了。

方法二 、交换解法

将整数转为字符串，再转为字符串数组；

在原数组基础上，设置两个索引，首位start 和 末位end，依次交换 start++ 和 end-- 相对应的字符；

将交换后的字符数组转换为字符串再转换为整数。

注意：若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;

}

}

方法三 、取模法

整数对10取余后拿到个位数字；

将整数除以10，再对10取余可以拿到倒数第二位数字，依次类推；

直到当前余数等于自身，可知已取到最高位；

将每次取到的余数依次乘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;

}

}