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
解题思路
本题如果使用栈的话，就会爆内存，栈最多支持1024，因此不能使用栈（如代码一，就会爆栈），因此用digit = x % 10，x /= 10，rev = rev * 10 + digit进行模拟「弹出」和「推入」数字。题目的数据存在超出int范围后会从正数变化，因此需要满足以下不等式，反之，false。

代码一（有问题的）

class Solution {
public:
    int reverse(int x) {
        bool flag=false;
        if(x<0)//说明是负数
          flag=true;
        x=abs(x);
        int k=0;
        stack<int> s;
        if(x==0) return 0;
        while(x){
            s.push(x%10);
            x/=10;
            k++;
        }
        int i=1,cnt=1;
        while(cnt<=k){
            x+=i*s.top();
            s.pop();
            i*=10;
            i++;
        }
        if(flag) return -x;
        else return x;
    }
}

代码二

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

代码三（不禁用long的写法）
将整数转换成字符串，再用 long去判断合法与否

class Solution {
public:
    int reverse(int x) {
        // 改成字符数组
        string chars = to_string(x);

        // 有负号则 l = 1，无负号则 l = 0
        int l = (chars[0] == '-') ? 1 : 0;
        int r = chars.size() - 1;

        // 从两侧向中间逼近，交换字符
        while (l < r) {
            swap(chars[l], chars[r]);
            ++l; --r;
        }
        // 先转换为 long long，用来检测是否溢出
        long long reversed = stoll(chars);
        if (reversed > INT_MAX || reversed < INT_MIN) {
            return 0;
        }
        // 再转换为 int
        return static_cast<int>(reversed);
    }
};

代码四
直接转换成long long处理

class Solution {
public:
    int reverse(int x) {
        long long x_ll = static_cast<long long>(x);
        long long ans = 0;

        while (x_ll != 0) {
            int digit = x_ll % 10; // 个位
            x_ll /= 10;
            ans = ans * 10 + digit;
        }
        
        // 溢出则返回 0
        if (ans > INT_MAX || ans < INT_MIN) return 0;
        return static_cast<int>(ans);
    }
};