Leet Code OJ 7. Reverse Integer_oj系统reverse digits-优快云博客

本文探讨了如何实现整数的反转，并考虑了在32位整数范围内的溢出处理。通过两种不同的实现方式对比，展示了如何在每一步计算中检查溢出情况。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Reverse digits of an integer.

Example1: x = 123, return 321
Example2: x = -123, return -321

Have you thought about this?
Here are some good questions to ask before coding. Bonus points for you if you have already thought through this!

If the integer’s last digit is 0, what should the output be? ie, cases such as 10, 100.

Did you notice that the reversed integer might overflow? Assume the input is a 32-bit integer, then the reverse of 1000000003 overflows. How should you handle such cases?

For the purpose of this problem, assume that your function returns 0 when the reversed integer overflows

大意：
题目要求将一个数反转，如123反转为321，但是有一点需要注意，要考虑溢出，32位的Integer范围是：-2147483646 ~ 2147483646
1. 假如一开始就传入大于或小于这个范围的值，要怎么处理
2. 如果反转后的值大于或小于这个范围的值，要怎么处理

我的思路是：
首先把int值强转为long来计算，然后在while内，从个位开始反转

我的代码：

public class Solution {
    public int reverse(int x) {
        int flag = 1;
        long nx = (long) x;
        if(nx < 0){
            flag = -1;
            nx = -nx;
        }
        if(nx > Integer.MAX_VALUE){
            return 0;
        }
        if(nx < 10){
            return x;
        }
        long sum = 0;
        //反转
        while(nx != 0){
            sum = sum*10 + nx%10;
            nx /= 10;
        }
        if(sum > Integer.MAX_VALUE){
            return 0;
        }
        return ((int)sum * flag);
    }
}

Discussion的优秀代码：
它的高明之处是：在反转的每一步计算过程中，判断当前的sum是否溢出，然后做处理；
而我的做法是，在开始和结束处处理溢出，所以代码没那么简洁

public class P7 {
    public int reverse(int x) {
        long rev= 0;
        while( x != 0){
            rev= rev*10 + x % 10;
            x= x/10;
            if( rev > Integer.MAX_VALUE || rev < Integer.MIN_VALUE)
                return 0;
        }
        return (int) rev;
    }
}