【力扣】7.整数翻转

快来打我* 2022-10-21 03:47 144阅读 0赞

### 文章目录 ###

*  题目
 *  利用数组+String进行翻转
 *  【官方算法】利用数学方法进行翻转

# 题目 #

给你一个 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

# 利用数组+String进行翻转 #

> 先看一下我写的，其中有两个致命的问题
> 
> 1.  用的是字符串+数组，其实这题是不建议用数组的方式
> 2.  用了Double ，题目中明确表示：假设环境不允许存储 64 位整数（有符号或无符号）。
> 
> 虽然最后也能够提交。但是却已经跑题了，这个只是给大家一个思路，轻喷哈！

class Solution {
        
        public int reverse(int x) {
        
              
            String s = String.valueOf(x);
    
            //将s分割
            char[] chars = s.toCharArray();
    
        if (x>Integer.MAX_VALUE || x<Integer.MIN_VALUE){
        
                return 0;
            }
            //判断
            if (chars.length == 1) {
        
               return turnInt(chars);
            } else if (chars[0] == '-') {
        
                char[] jian = jian(chars);
                return turnInt(jian);
            } else if (chars[chars.length - 1] == '0') {
        
                char[] ifZero = ifZero(chars);
              return  turnInt(ifZero);
            } else {
        
                char[] common = common(chars);
               return turnInt(common);
            }
    
    
        }
    
         public static int turnInt(char[] chars) {
        
            String s = String.valueOf(chars);
             double v = Double.parseDouble(s);
           if (v>Integer.MAX_VALUE || v<Integer.MIN_VALUE){
        
                return 0;
            }
                return (int)v;
            
        }
    
        public static char[] common(char[] chars) {
        
            char[] chars1 = new char[chars.length];
            int j = 0;
            for (int i = chars.length - 1; i >= 0; i--) {
        
                chars1[j] = chars[i];
                j++;
            }
            return chars1;
        }
    
        public static void out(char[] chars) {
        
            for (char aChar : chars) {
        
                System.out.print(aChar);
            }
        }
    
        //如果第一个字符是减的话,那么第一个位置的负号不变
        public static char[] jian(char[] chars) {
        
            char[] chars1 = new char[chars.length];
            chars1[0] = chars[0];
            int j = 1;
            for (int i = chars.length - 1; i > 0; i--) {
        
                chars1[j] = chars[i];
                j++;
            }
    
            return chars1;
        }
    
        //如果第一个字符是0
        public static char[] ifZero(char[] chars) {
        
    
            char[] chars1 = new char[chars.length - 1];
            int j = 0;
            for (int i = chars.length - 1; i > 0; i--) {
        
                chars1[j] = chars[i - 1];
                j++;
            }
    
            return chars1;
        }
    
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JsYWNrX0N1c3RvbWVy_size_16_color_FFFFFF_t_70]

# 【官方算法】利用数学方法进行翻转 #

> 下面我们来看看官方对此题的讲解，发现官方是用的数学方法推导出公式，然后进行处理，性能优化和处理上都得到了很大的提升。

[官方思路][Link 1]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JsYWNrX0N1c3RvbWVy_size_16_color_FFFFFF_t_70 1]

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

这里对式子进行了整理，发现我们只需要考虑 rev 和 (INT\_MAX)/10 便可以

*  如果左边括号里的式子大于0，那么 \* 10 后，肯定大于右边的式子，所以在最后一次出栈前对比发现已经超过最大值，那么肯定就超了。
 *  如果 = ，这里 = 我感觉用的很巧妙，因为 = 说明长度是一样的。然后判断余数。
 *  如果小于，我认为的情况下是因为rev已经小于最大值，那么其首位肯定也没最大值大，那么必然是一直小于最大值的。

看了官方的，真的很受启发。估计是我比较菜的原因，哈哈。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JsYWNrX0N1c3RvbWVy_size_16_color_FFFFFF_t_70 2]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JsYWNrX0N1c3RvbWVy_size_16_color_FFFFFF_t_70]: /images/20221021/27047fd10d4a484084af841d6dcd30e8.png
[Link 1]: https://leetcode-cn.com/problems/reverse-integer/solution/zheng-shu-fan-zhuan-by-leetcode-solution-bccn/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JsYWNrX0N1c3RvbWVy_size_16_color_FFFFFF_t_70 1]: /images/20221021/a83daa0873a44c869ff593d1a2494e7a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JsYWNrX0N1c3RvbWVy_size_16_color_FFFFFF_t_70 2]: /images/20221021/ae441d71017b42bb96c41c78fb262c61.png