题目
难度:简单
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 store integers within the 32-bit signed integer range: [−231, 231 − 1]. For the purpose of this problem, assume that your function returns 0 when the reversed integer overflows.
反转整型数。
解法概览
解法一 利用字符串反转后进行整型转换
【最好】
执行用时: 40 ms, 在Reverse Integer的Java提交中击败了72.19% 的用户
内存消耗: 27.4 MB, 在Reverse Integer的Java提交中击败了64.88% 的用户
【最差】
显示详情
执行用时: 81 ms, 在Reverse Integer的Java提交中击败了5.98% 的用户
内存消耗: 27.4 MB, 在Reverse Integer的Java提交中击败了64.88% 的用户
此算法执行不稳定,而且比较耗时。
public int reverse(int x) {
boolean isNegative = false;
if(x < 0) {
isNegative = true;
}
String v = String.valueOf(x);
v = v.replace("-", "");
char[] array = v.toCharArray();
StringBuilder sb = new StringBuilder();
for(int i = array.length - 1; i >= 0 ; i--) {
sb.append(array[i]);
}
if(isNegative) {
try {
return -Integer.parseInt(sb.toString());
} catch (NumberFormatException e) {
return 0;
}
}else {
try {
return Integer.parseInt(sb.toString());
} catch (NumberFormatException e) {
return 0;
}
}
}
解法二 整型变量互换
【最好】
算法非常稳定
执行用时: 43 ms, 在Reverse Integer的Java提交中击败了64.62% 的用户
内存消耗: 38.1 MB, 在Reverse Integer的Java提交中击败了7.49% 的用户
【最差】
执行用时: 44 ms, 在Reverse Integer的Java提交中击败了56.63% 的用户
内存消耗: 37.8 MB, 在Reverse Integer的Java提交中击败了21.81% 的用户
此算法执行非常稳定。
public int reverse(int x) {
int ret = 0;
while (x != 0) {
// 如果大小改变则溢出,则返回0;
if (ret != ret * 10 / 10) {
return 0;
}
ret *= 10;
// 同上
if (ret != ret + x % 10 - x % 10) {
return 0;
}
ret += x % 10;
x = (x - x % 10) / 10;
}
return ret;
}
解法三 整型变量互换(同官方解法)
【最好】
执行用时: 26 ms, 在Reverse Integer的Java提交中击败了87.22% 的用户
内存消耗: 27.1 MB, 在Reverse Integer的Java提交中击败了64.88% 的用户
【最差】
执行用时: 59 ms, 在Reverse Integer的Java提交中击败了11.29% 的用户
内存消耗: 37.6 MB, 在Reverse Integer的Java提交中击败了23.28% 的用户
此算法执行也是相对稳定,平均在40ms左右,偶尔能爆出20多ms。
public int reverse(int x) {
int rev = 0;
while (x != 0) {
int pop = x % 10;
x /= 10;
if (rev > Integer.MAX_VALUE / 10 || (rev == Integer.MAX_VALUE / 10 && pop > 7))
return 0;
if (rev < Integer.MIN_VALUE / 10 || (rev == Integer.MIN_VALUE / 10 && pop < -8))
return 0;
rev = rev * 10 + pop;
}
return rev;
}
解法四 最优解
【最好】
执行用时: 24 ms, 在Reverse Integer的Java提交中击败了91.89% 的用户
内存消耗: 27.1 MB, 在Reverse Integer的Java提交中击败了64.88% 的用户
【最差】
执行用时: 43 ms, 在Reverse Integer的Java提交中击败了64.62% 的用户
内存消耗: 37.8 MB, 在Reverse Integer的Java提交中击败了20.92% 的用户
此算法执行也是相对稳定,平均在40ms左右,偶尔能爆出20多ms。
与解法三比较,做了以下优化:
1)、把rev * 10 改成 (rev << 3) + (rev << 1),其实效果也一般。
2)、把Integer.MAX_VALUE / 10改成214748364,也不见得能提高多少。
public int reverse(int x) {
int rev = 0;
while (x != 0) {
int pop = x % 10;
x /= 10;
if (rev > 214748364 || (rev == 214748364 && pop > 7))
return 0;
if (rev < -214748364 || (rev == -214748364 && pop < -8))
return 0;
rev = (rev << 3) + (rev << 1) + pop;
}
return rev;
}