LeetCode刷题笔记Day2——7.整数反转

2.整数反转（原题号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

题型：

class Solution {
public:
    int reverse(int x) {
        
    }
};

---

提交 1（数学方法）

执行用时 4 ms

内存消耗 6 MB

源代码

class Solution {
public:
    int reverse(int x) {
        int sign, i, j, bits, bit;
        bool flag = false;
        int max_num[10] = {2, 1, 4, 7, 4, 8, 3, 6, 4, 7};
        int rev = 0;
        if(x == -2147483648){
            return 0;
        }
        if(x < 0){
            sign = -1;
            x *= -1;
        }
        else if(x == 0){
            return 0;
        }
        else {
            sign = 1;
        }
        bits = log10(x);
        if(bits > 9){
            return 0;
        }else if (bits == 9){
            flag = true;
        }
        for(i = bits, j = 0; i >= 0; i--, j++){
            bit = x % 10;
            if(flag){
                if(max_num[j] < bit){
                    return 0;
                }else if(max_num[j] > bit){
                    flag = false;
                }
            }
            x /= 10;
            rev = rev*10 + bit;
        }
        rev *= sign;
        return rev;
    }
};

思路总结

先进行特殊值处理。因为-xxxx负数无法镜像为xxxx-，所以用sign表示符号，最后镜像的结果再乘以sign。

计算出整数位数bits，因为题目有限制**“假设环境不允许存储 64 位整数（有符号或无符号）。”，所以将会有输入的int镜像后超出int范围的情况，并且不能使用long long int或者是 double。所以提出按位比较**。如果输入为十位数，则才有可能达到int极限(max_num)，接着在rev加上bit（该位）之前，加一条判断，如果为九位数且当前位数要比max_num的相应位数小，则其大小一定不会超过max_num了；如果位数比max_num的相应位数大，则该数一定超过max_num， 加上一定超过int极限，所以return 0。

---

题解 1 (官方题解)

执行用时 0 ms

内存消耗 5.8 MB

源代码

class Solution{
public:
    int reverse(int x){
        int rev = 0;
        while (x != 0){
            if (rev < -2147483648 / 10 || rev > 2147483647 / 10){
                return 0;
            }
            int digit = x % 10;
            x /= 10;
            rev = rev * 10 + digit;
        }
        return rev;
    }
};

思路总结

原题解证明就不再阐述，基本思路和我的一样，他的做法要更加简洁。因为在可能溢出之前rev只可能是小于九位数，所以不需要按位判断，在rev到达十位数之前和INT_MAX / 10判断就可以了。

---

题解 2（暴力算法）

执行用时 4 ms

内存消耗 5.9 MB

本题解无视题目假设环境不允许存储 64 位整数（有符号或无符号）

还是官方的算法牛逼

源代码

class Solution {
public:
    int reverse(int x) {
        long long int rev = 0;
        const int MIN = -2147483648;
        const int MAX = 2147483647;
        int digit;
        while(x != 0){
            digit = x % 10;
            rev = rev * 10 + digit;
            x /= 10;
        }
        if(rev < MIN || rev > MAX) return 0;
        else return rev;
    }
};