leetcode 7： 整数反转

# leetcode 7： 整数反转

给你一个 32 位的有符号整数 `x` ，返回将 `x` 中的数字部分反转后的结果。

如果反转后整数超过 32 位的有符号整数的范围 `[−231, 231 − 1]` ，就返回 0。

**假设环境不允许存储 64 位整数（有符号或无符号）。**

**示例 1：**

```
输入：x = 123
输出：321
```

**示例 2：**

```
输入：x = -123
输出：-321
```

**示例 3：**

```
输入：x = 120
输出：21
```

**示例 4：**

```
输入：x = 0
输出：0
```

**提示：**

- `-231 <= x <= 231 - 1`

Related Topics

数学

## 思路：

关于越界的问题，因为每一次计算的新结果都是`result * 10 + temp % 10`这个公式计算。只需要保证`result * 10 + temp % 10 <= Integer.Max_Value`。

参考leetcode官方分析思路：

* -2147483648<=result*10 + digit <= 2147483647
* 因为给的值X它肯定是一个整数，而且它的最高位<=2，所以可能发生溢出时，digit<=2，我们只需要判断result*10的值。
* 上面的式子也就等价于-2147483648<=result*10 <= 2147483647
* 也等价于min/10<= result <= max/10
* 所以当result<min/10 或者 当result >max/10时，就会发生溢出。

```java
public int reverse(int x) {
    int temp = x;
    if(temp < 0){
        temp = -temp;
    }
    
    int result = 0;

    while(temp != 0){
         //214748365 * 10 直接越界
        // 只要 result * 10 + temp % 10 <= Integer.Max(2147483647) 就不会越界
        // 因为x是一个整数 那么它的最高位肯定是 <=2
        //所以只要保证 result * 10 <
        if(result < Integer.MIN_VALUE/10 || result > Integer.MAX_VALUE/10){
            return 0;
        }
        result = result * 10 + temp % 10;
        temp /= 10;
    }
    if(x < 0){
        result = -result;
    }
    return result;
}
解答成功:
            执行耗时:0 ms,击败了100.00% 的Java用户
            内存消耗:39 MB,击败了5.01% 的Java用户
```

## 思路2：

改进：经过观看leetcode官方代码发现，-2%10=-2，所以我们就没有必要区分正负数，可以统一代码。

```java
public int reverse(int x) {

    int result = 0;

    while(x != 0){
         //214748365 * 10 直接越界
        // 只要 result * 10 + temp % 10 <= Integer.Max(2147483647) 就不会越界
        // 因为x是一个整数 那么它的最高位肯定是 <=2
        //所以只要保证 result * 10 <
        if(result < Integer.MIN_VALUE/10 || result > Integer.MAX_VALUE/10){
            return 0;
        }
        result = result * 10 + x % 10;
        x /= 10;
    }
    return result;
}
```