LeetCode07, inversión de enteros

tema

Método: (bajo)

class Solution {
    
    
    public int reverse(int x) {
    
    
            if(x==0)
                return 0;
            int flag=x>0?1:-1;
            x*=flag;//转变为整数
            String x_str=Integer.toString(x);
            String reverse = new StringBuffer(x_str).reverse().toString();
            int res;

           try{
    
    
               res = Integer.parseInt(reverse);
               res = res*flag;
           }catch (NumberFormatException e){
    
    
               return 0;
           }
            return res;

    }
}

El segundo enfoque: (bajo)

class Solution {
    
    
     public int reverse(int x) {
    
    
          if(x==0)
            return 0;
        if(x%10==0){
    
    //不可能溢出
            if(x<0){
    
    
                x = -x;
                return -Integer.parseInt(new StringBuilder(Integer.toString(x)).reverse().toString());
            }else  return Integer.parseInt(new StringBuilder(Integer.toString(x)).reverse().toString());

        }
        int flag=x>0?1:-1;
       if(x==Integer.MIN_VALUE){
    
    
            return 0;
        }
        x = x*flag;
        //x的长度等于9

        if(x>1000000000){
    
    //有可能溢出
            String s = Integer.toString(x);
            StringBuilder rev = new StringBuilder(s).reverse();//反转跟最值比较
            StringBuilder res = new StringBuilder();
            StringBuilder sb_MIN = new StringBuilder(Integer.toString(Integer.MIN_VALUE));
            StringBuilder sb_MAX = new StringBuilder(Integer.toString(Integer.MAX_VALUE));
            if(flag<0)//负数
                res.append("-");
            res.append(rev);
            if(flag<0){
    
    
                if(res.compareTo(sb_MIN)<0)
                    return Integer.parseInt(res.toString());
            }else {
    
    
                if(res.compareTo(sb_MAX)<0){
    
    
                    return Integer.parseInt(res.toString());
                }
            }
            return 0;

        }
        return flag*Integer.parseInt(new StringBuilder(Integer.toString(x)).reverse().toString());
        }
}

El tercer enfoque: consulte la solución oficial. . . . . Estoy demasiado bajo

Tome el resto y, a su vez, construya el número inverso de este entero. Cada vez que se construye un bit, se debe juzgar si se desborda. El rango requerido de la pregunta es
suponer que nuestro entorno solo puede almacenar el siguiente entero de 32 bits con signo, entonces el rango de valores es [−2 ³¹ , 2 ³¹ - 1]. De acuerdo con esta suposición, si el entero se desborda después de la inversión, devuelve 0.
Es decir, el último bit del valor marginal es 7 o -8;

class Solution {
    
    
    public int reverse(int x) {
    
    
        int rev = 0;
        while (x != 0) {
    
    
            int pop = x % 10;
            x /= 10;
            if (rev > Integer.MAX_VALUE/10 || (rev == Integer.MAX_VALUE / 10 && pop > 7)) return 0;
            if (rev < Integer.MIN_VALUE/10 || (rev == Integer.MIN_VALUE / 10 && pop < -8)) return 0;
            rev = rev * 10 + pop;
        }
        return rev;
    }
}