【LeetCode第七题】整数反转-优快云博客

本文链接：https://blog.youkuaiyun.com/Go_forward_/article/details/132386051

题目：整数反转

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

如果反转后整数超过 32 位的有符号整数的范围在这里插入图片描述
，就返回 0。

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

示例 1：

输入：x = 123
输出：321
示例 2：

输入：x = -123
输出：-321
示例 3：

输入：x = 120
输出：21
示例 4：

输入：x = 0
输出：0

提示：

-231 <= x <= 231 - 1

https://leetcode.cn/problems/reverse-integer/

思路：利用字符串比较判断是否超过大小限制

该题最大的难点在于整数反转后，判断是否超过 32 位的有符号整数的范围

巧妙地利用了字符串比较来判断是否超过大小限制
使用了string的compare函数进行字符串比较

通过除以pow(10, 9)是否不等于0来判断x是否达到10位，达到10位进行是否超过长度判断JudgeExceedLimit

代码：击败100%（巧合）

class Solution {
public:
    bool JudgeExceedLimit(int x) {
        if (x == -2147483648) {
            return 0;
        }
        string strPlus = std::to_string(2147483648);
        string strMinus = std::to_string(2147483647);
        bool isMinus = false;
        if (x < 0) {
            isMinus = true;
        }
        int absX = abs(x);
        string strX = std::to_string(absX);
        string reverseStrX;
        for (int i = strX.size() - 1; i >= 0; i--) {
            reverseStrX += strX[i];
        }
        if (isMinus) {
            if (strMinus.compare(reverseStrX) < 0) {
                return true;
            }
        } else {
            if (strPlus.compare(reverseStrX) < 0) {
                return true;
            }
        }
        return false;
    }
    int reverse(int x) {
        int nine = pow(10, 9);
        if (x / nine != 0) {
            if (JudgeExceedLimit(x)) {
                return 0;
            }
        }
        int n = 0;
        int divisor = 10;
        vector<int> vec(10, 0);
        int absx = abs(x);
        if (x != 0 && x != -2147483648) {
            n = 1;
            vec[n - 1] = absx % 10;
        }
        else {
            return 0;
        }
        while (absx / divisor != 0) {
            absx = absx / divisor;
            n++;
            vec[n - 1] = absx % 10;
        }
        int ret = 0;
        // if (n == 10) {
        //     if ((vec[0] > 2)) {
        //         return 0;
        //     }
        //     if (vec[n - 1] > 7) {
        //         return 0;
        //     }
        // }
        for (auto it : vec) {
            ret += it * pow(10, --n);
        }
        if (x < 0) {
            return -ret;
        } else {
            return ret;
        }
    }
};