L7. 整数反转

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

示例 1:

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

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

输入: 120
输出: 21
注意:

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

1.还是有部分数据无法通过

class Solution {
    public static void main(String[] args) {
        Solution ss = new Solution();
        System.out.println(ss.reverse(1534236469));
        int now = 0x7FFFFFFF;//这里就是2^31-1;
        System.out.println(now + 1);//这里输出就是-1
    }
    public int reverse(int x) {
        if(x == 0) return 0;
        int sign = 1;
        if(x < 0) {
            sign = -1;
            x = -x;
        }
        int[] num = new int[32];
        int index = 0;
        while(x != 0){
            num[index++] = x % 10;
            x /= 10;
        }
        int ans = 0;
        for(int i = 0; i < index; i++){
            ans = ans * 10 + num[i];
            if(ans > 0x7FFFFFFF ) return 0;
        }
        return ans * sign;
    }
}

2.另一种尝试

class Solution {
    public int reverse(int x) {
        if(x == 0) return 0;
        int sign = 1;
        if(x < 0) {
            sign = -1;
            x = -x;
        }
        int[] num = new int[32];
        int index = 0;
        while(x != 0){
            num[index++] = x % 10;
            x /= 10;
        }
        int ans = 0;
        for(int i = 0; i < index; i++){
            ans = ans * 10 + num[i];
            if(ans < 0) return 0;
        }
        return ans * sign;
    }
}

输入：
1534236469
输出：
1056389759
预期：
0
原因在于最后一次运算，

		int now = 964632435;
        System.out.println(now * 10);//这里输出并不是< 0, 而是1056389758
        System.out.println(now * 10 + 1);

乘法器原理：
实质是根据被乘数（1011_1011）根据乘数（1101）进行移位相加，不一定超出最大值，就变为负值了，中间可能发生截断
2.改进措施，直接用long存储，涉及的全部变量，都必须更改，你的方法就可以用了
注意：

	if(x < 0) {
            sign = -1;
            x = -x;注意这里如果值为-2147483648，
            //即使x = -x，依然为负值，所以x，必须设为long

        }

又出现一个神奇的情况，（long）%(10)会自动转为double类型，应该是编译器的问题，LeetCode能通过
最终通过的写法

class Solution {
    int reverse(int a) {
        long x = a;
        if(x == 0) return 0;
        int sign = 1;
        if(x < 0) {
            sign = -1;
            x = -x;//注意这里如果值为-2147483648，即使x = -x，依然为负值，所以x，必须设为long

        }
        long[] num = new long[32];
        int index = 0;
        while(x != 0){
			 num[index++] =(long) x % 10;//去除long也是可以
            x /= 10;
        }
        long ans = 0;
        for(int i = 0; i < index; i++){
            ans = ans * 10 + num[i];
            if(ans > 0x7FFFFFFF) return 0;
            //if(sign == 1 && ans > 0x7FFFFFFF ) return 0;
            //if(sign == -1 && ans > 0x80000000) return 0;
            //因为你判断的是倒置之后的，所以这里无需讨论
        }
        return (int)ans * sign;
    }
}

2.其实没必要专门放到数组里，直接使用就可以了，同时为了避免出现x = -x时仍为负值，这里直接带符号比较

class Solution {
    public int reverse(int x) {
        //这里不再判断符号了， 也不需要数组存储
        int ans = 0;
        while( x != 0){
            int now = x % 10;//时刻比较当前的各位数
            if(ans > Integer.MAX_VALUE/10 || ans == Integer.MAX_VALUE/10 && now > 7){
                return 0;
            }
            if(ans < Integer.MIN_VALUE/10 || ans == Integer.MIN_VALUE/10 && now < -8){
                return 0;
            }
            ans = ans * 10 + now;
            x /= 10;
        }
        return ans;
    }
}