[LeetCode] 字符串+ 整数反转

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

示例 1:

输入: 123
输出: 321
 示例 2:

输入: -123
输出: -321
示例 3:

输入: 120
输出: 21
注意:

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

1.我们分别用字符串和10取整取余两种方法进行操作，从结果我们很容易看出字符串操作很慢，应尽量避免

2.需要关注反转后的溢出问题

3.

字符串：整数->字符串->整数

10取整取余：取余实现反转，取整实现出栈

class Solution {	
	/*
	 * 通过 整数->字符串->整数, 在字符串位进行操作
	 * 执行用时 : 11 ms, 在所有Java提交中击败了41.00%的用户
	 * 内存消耗 :33.6 MB, 在所有Java提交中击败了80.09%的用户
	 */
	public static int reverse0(int x) {
		long n=(long)x;
		long xresult;
		//通过 整数->字符串->整数 进行整数反转
		String s=new StringBuffer(Math.abs(n)+"").reverse().toString();
		if(x>0)
			xresult=Long.parseLong(s);
		else
			xresult=-Long.parseLong(s);
		//判断溢出
		if(xresult>Integer.MAX_VALUE||xresult<Integer.MIN_VALUE) {
			return 0;
		}
		else {
			return (int)xresult;
		}
	}
	
	/*无法解决颠倒后整数溢出的问题*/
	public static int reverse1(int x) {
		int rev=0;
		while(x!=0) {
			int pop=x%10;
			x=x/10;
			rev=rev*10+pop;
	    	//System.out.println(rev);
		}
		return rev;
	}
	
	/*
	 * 通过除以10取余数和取整数，直接在整数位进行操作
	 * 执行用时 :5 ms, 在所有Java提交中击败了99.43%的用户
	 * 内存消耗 :33.6 MB, 在所有Java提交中击败了80.49%的用户
	 */
	public static int reverse2(int x) {
		int rev=0;
		while(x!=0) {
			int pop=x%10; //取得余数
			//System.out.println(rev);
			x/=10; //进行去位
			//判断是否正溢出 21474836487
			if(rev>Integer.MAX_VALUE/10||(rev==Integer.MAX_VALUE/10&&pop>7)) {
				return 0;
			}
			//判断是否负溢出 -2147483648
			if(rev<Integer.MIN_VALUE/10||(rev==Integer.MIN_VALUE/10&&pop<-8)) {
				return 0;
			}
			rev=rev*10+pop; //求出反转整数
		}
		return rev;
	}


    public static void main(String[] args) {
    	
    	int result3=reverse0(-2147483648);
    	System.out.println(result3);
    	System.out.println();
    	
    	int result1=reverse1(-2147483647);
    	System.out.println(result1);
    	System.out.println();
    	
    	int result2=reverse2(-2147483647);
    	System.out.println(result2);
    	System.out.println();
    }
}