[c++]关于倒转32位int整数的范围控制问题

题目来源：leetcode Reverse Integer

Given a 32-bit signed integer, reverse digits of an integer.

Example 1:            Example 2:          Example 3:

Input: 123             Input: -123         Input: 120

Output: 321          Output: -321       Output: 21

Note:
Assume we are dealing with an environment which could only store integers within the 32-bit signed integer range: [−2³¹,  2³¹ − 1]. For the purpose of this problem, assume that your function returns 0 when the reversed integer overflows.

思路： 

• 考虑三种情况：

1. 1. 数值本身就溢出。
   2. 数值将要溢出，分界在未知数与INT_MAX位数相同。
   3. 数值在安全范围内。

• 解决方案：

1. 1. 先判断溢出，若溢出直接返回0
   2. 边按位比较，边倒转，判断溢出，若溢出返回0
   3. 直接倒转

前提处理：

int m=x,i=1,ten=1;//i记录位数，ten记录最高位数要*10的
while(m/=10){ ++i;ten*=10;}
if(i<10) m=reversemin(x,i,ten);
else m=reversemax(x,i,ten);

判断数值溢出：

1 unsigned int y = x;//扩大范围
2 if(x<0) y=-x;
3 if(y>INT_MAX) return 0;

按位比较，并倒转：

int reversemax(int x,int i,int ten)
{
    int sign=1;
    if(x<0) {x=-x; sign=-1;}//负数变为正数，sign还原负数
    int m=0,max=INT_MAX;
    while (i--) {
            int rest = x % 10;
            int mrest=max/ten;
            if(rest>mrest) return 0;//与INT_MAX按位比较，如果大于则已经溢出，返回0
            else if(rest<mrest) break;//如果小于则进入了安全范围，跳到安全的倒转
            m += rest * ten;//只有在相等的情况才需要进行下一次比较
            x /= 10;
            max=max-mrest*ten;
            ten /= 10;
        }
    if(ten==0) return m*sign;
    ++i;//最后一次循环中止时，没有操作，所以还原被删去的位数
    
    while (i--) {//正常倒转
            int rest = x % 10;
            m += rest * ten;
            x /= 10;
            ten /= 10;
        }
    return m*sign;
    
}

！负数取模之后是负数，无法进行比较，所以先取正。

！判断是否倒转完，第16行，不能用位数，因为中断出来位数也减了1

直接倒转：

 1 int reversemin(int x, int i, int ten)
 2     {
 3         int m = 0;
 4         while (i--) {
 5             int rest = x % 10;
 6             m += rest * ten;
 7             x /= 10;
 8             ten /= 10;
 9         }
10         return m;
11 }

整体代码：

class Solution {
public:
    int reverse(int x) {
       unsigned int y = x;
        if(x<0) y=-x;
       if(y>INT_MAX) return 0;
       int reversemin(int x, int i, int ten);
       int reversemax(int x,int i,int ten);
       int m=x,i=1,ten=1;
        while(m/=10){ ++i;ten*=10;}
        if(i<10) m=reversemin(x,i,ten);
        else m=reversemax(x,i,ten);
        return m;
    }
};
int reversemin(int x, int i, int ten)
    {
        int m = 0;
        while (i--) {
            int rest = x % 10;
            m += rest * ten;
            x /= 10;
            ten /= 10;
        }
        return m;
}
int reversemax(int x,int i,int ten)
{
    int sign=1;
    if(x<0) {x=-x; sign=-1;}
    int m=0,max=INT_MAX;
    while (i--) {
            int rest = x % 10;
            int mrest=max/ten;
            if(rest>mrest) return 0;
            else if(rest<mrest) break;
            m += rest * ten;
            x /= 10;
            max=max-mrest*ten;
            ten /= 10;
        }
    if(ten==0) return m*sign;
    ++i;
    
    while (i--) {
            int rest = x % 10;
            m += rest * ten;
            x /= 10;
            ten /= 10;
        }
    return m*sign;
    
}

 @jm_epiphany

---

2019-03-23 新更新内容：之前一直没有看别人的解法，发现这样太过繁琐了，java中int是用补码表示的，当这个数超出范围时，他肯定和之前的码不一样了，判断不一样即可

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;
}