Algorithm: Reverse Integer之Java实现（含最优解）

题目

难度：简单

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;
		}