【LeetCode刷题记录】7.Reverse Integer

发表于
字数统计: 375 字 | 阅读时长 ≈ 2 分钟

Description:

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.

Note:
The input is assumed to be a 32-bit signed integer. Your function should return 0 when the reversed integer overflows.

解体思路：这道题目比较简单，难点在于溢出的判断与处理。

Solutions：

Solutions 1：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
int reverse(int x) {  
        const int max = 0x7fffffff;  //int最大值  
        const int min = 0x80000000;  //int最小值  
        long long sum = 0;   
          
        while(x != 0)  
        {  
            int temp = x % 10;  
            sum = sum * 10 + temp;  
            if (sum > max || sum < min)   //溢出处理  
            {  
                sum = sum > 0 ? max : min;    
                return sum;  
            }  
            x = x / 10;  
        }  
        return sum;  
    }

将int数据类型能表示的最大值与最小值用十六进制表示出来，虽然有效，但是代码里0x7fffffff这种 hard code 不够优雅，而且容易出错。

Improved Solution 1:

1
2
3
4
5
6
7
8
9
10
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;
    }

int数据类型能表现的上下限以 Integer.MAX_VALUE 和 Integer.MIN_VALUE 表示，更加优雅简洁。

Solution 2:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public int reverse(int x)
{
    int result = 0;
    while (x != 0)
    {
        int tail = x % 10;
        int newResult = result * 10 + tail;
        if ((newResult - tail) / 10 != result)
        { return 0; }
        result = newResult;
        x = x / 10;
    }
    return result;
}

原理： If overflow exists, the new result will not equal to the previous one.