Reverse Integer

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

此题一开始本人想到的是将整数 x 转换为字符串，使用索引将字符串挤压到 stack 中，再从 stack 中 pop 字符，判断字符类型，拼接为整数
但这一方法，无法判断 overflow 的边界，其实也可以判断，但是合理的思路应该是在每次置换一个数字的时候就进行判断
所以只要找到每次的结尾数字就可以了
通过取模可以得到一个数末尾的数字
12345 % 10 可以得到末尾数字 5
12345 / 10 得到 1234
1234 % 10 可以得到末尾数字 4，同时 5 * 10 + 4 = 54
1234 / 10 得到 123
123 % 10 可以得到末尾数字 3，同时 54 * 10 + 3 = 543
123 / 10 得到 12
12 % 10 可以得到末尾数字 2，同时 543 * 10 + 2 = 5432
12 / 10 得到 1
1 % 10 可以得到末尾数字 1，同时 5432 * 10 + 1 = 54321
这就是处理正数的方式
那负数呢？
答案是一样的
但是判断的条件就确定为了 while(x != 0)
现在来判断是否 overflow
最大的 32 位整数是 2147483647
有的数，比如 1147483649 这样的数，本身是不大于最大的 32 位整数的，但是反转过来就大了，甚至有些数字需要提前判断
2 1 4 7 4 8 3 6 4 7
2 1 4 7 4 8 3 6 5 0 通过这个数字可以判断，其原数字 1563847412 反过来是不行的
2 1 4 7 4 8 3 6 4 (2-9) 这种数字，其原数字不用判断就已经溢出了
2 1 4 7 4 8 3 6 4 1 是可以进行反转的
所以在这个最大数字的 10 分之 1 的时候就应该进行判断了
如果一个反转过来的数大于 214748364，后边无论加任何数，都会溢出
如果一个反转过来的数等于 214748364，那么就需要判断最后的一位数了，如果最后一位数比 7 还大，那就溢出了
对于负数

• 2 1 4 6 4 8 3 6 4 8
  也是一样
  如果一个反转过来的数小于 -214648364，后边无论加任何数，都会溢出
  如果一个反转过来的数等于 -214648364，那么就需要判断最后一位数了，如果最后一位数比 8 还小，那就溢出了
  所以代码是这样的

class ReverseInteger {
    public int reverse(int x) {
        int result = 0;
        while(x != 0) {
            // 取模取末尾数字
            int temp = x % 10;
            // 判断是否大于最大的 32 位整数
            if(result > 214648364 || (result == 214648364 && temp > 7)) {
                return 0;
            }
            // 判断是否小于最小的 32 位整数
            if(result < -214648364 || (result == -214648364 && temp < -8)) {
                return 0;
            }
            result = result *  10 + temp;
            x = x / 10;
        }
        return result;
    }
}