精华内容
下载资源
问答
  • leetcode 整数反转 java

    2020-02-26 11:01:28
    给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。 示例 1: 输入: 123 输出: 321 示例 2: 输入: -123 输出: -321 示例 3: 输入: 120 输出: 21 注意: 假设我们的环境只能存储得下 32 位的有...

    题干

    给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。

    示例 1:

    输入: 123
    输出: 321
    

    示例 2:

    输入: -123
    输出: -321
    

    示例 3:

    输入: 120
    输出: 21
    

    注意:

    假设我们的环境只能存储得下 32 位的有符号整数,则其数值范围为 [−231, 231 − 1]。请根据这个假设,如果反转后整数溢出那么就返回 0。

    想法

    我们需要取到每一位数,所以取10的余
    同时判断越界即可

    Java代码

    class Solution {
        public int reverse(int x) {
            //每一位的数
            int pop=0;
            //累计数
            int res=0;
            while(x!=0){
                pop=x%10;
                x=x/10;
                //越界
               if (res > Integer.MAX_VALUE/10 || (res == Integer.MAX_VALUE / 10 && pop > 7)) return 0;
                if (res < Integer.MIN_VALUE/10 || (res == Integer.MIN_VALUE / 10 && pop < -8)) return 0;
                res=res*10+pop;
    
            }
    
            return res;
        }
    }
    

    代码均上传到我的githttps://github.com/ragezor/leetcode

    展开全文
  • LeetCode整数反转-java

    2020-04-03 11:10:05
    给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。 示例 1: 输入: 123 输出: 321 示例 2: 输入: -123 输出: -321 示例 3: 输入: 120 输出: 21 注意: 假设我们的环境只能存储得下 32 ...
    给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。
    
    示例 1:
    
    输入: 123
    输出: 321
    
     示例 2:
    
    输入: -123
    输出: -321
    
    示例 3:
    
    输入: 120
    输出: 21
    
    注意:
    
    假设我们的环境只能存储得下 32 位的有符号整数,则其数值范围为 [231,  2311]。请根据这个假设,如果反转后整数溢出那么就返回 0。
    
    来源:力扣(LeetCode)
    链接:https://leetcode-cn.com/problems/reverse-integer
    著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。
    

    对于这个题目,最初的想法就是转化成StringBuilder,然后用reverse()方法,但是题目已经提示有溢出情况,就不得不考虑,一个简单粗暴的方法就是直接try catch return 0,实操起来确实有效。

    public static int reverse(int x){
    	int  result = 0;
    	try{
    		//直接简单粗暴取绝对值
    		StringBuilder sb = 
    		new StringBuilder(String.valueOf(Math.abs(x)));
    		if(x>0){
    			result = Integer.valueOf(sb.reverse().toString());
    		}else{
    			result = -Integer.valueOf(sb.reverse().toString());
    		}
    	}catch(Exception e){
    	//仅捕获异常,不做任何处理
    	}
    	return result;
    }
    

    通过但是这样有点太简单粗暴了,可以用Integer的最大最小值去判断范围,超出直接return 0;

    //耗时4ms
    public static int reserse1(int x){
    	 int  result = 0;
    	
    	 /** 
    	 注释掉部分 当反转结果不在Integer范围内时出错,
    	 且当x = Integer.MIN_VALUE时 Math.abs()方法会返回负值;
    	if(x>Integer.MAX_VALUE || x< Integer.MIN_VALUE){
    		return result;
    	}
    	StringBuilder sb = 
    		new StringBuilder(String.valueOf(Math.abs(x)));
    	if(x>0){
    		result = Integer.valueOf(sb.reverse().toString());
    	}else{
    		result = -Integer.valueOf(sb.reverse().toString());
    	} **/
    	if(x>=Integer.MAX_VALUE || X<= Integer.MIN_VALUE){
    		return result;
    	}
    	Long value = Long.parseLong(new StringBuilder(
    	String.valueOf(Math.abs(x))).reverse().toString());
    	if(x>0){
    		result = value.intValue();
    	}else{
    		result = -value.intValue();
    	}
    	return result;
    }
    

    Math.abs方法出错循环取余法

    public static int resever(int x){
    	int temp = 0;
    	int result = 0;
    	while(x!=0){
    		temp = x%10;
    		x = x/10;
    		result = result*10 +temp;
    	}
    	if(result>Integer.MAX_VALUE || result<Integer.MIN_VALUE){
    		result = 0;
    	}
    	return result;
    }
    
    展开全文
  • 如果反转整数超过 32 位的有符号整数的范围 [−231,231−1][−2^{31}, 2^{31} − 1][−231,231−1] ,就返回 0。 假设环境不允许存储 64 位整数(有符号或无符号)。 解析: 该题可以借助字符串实现,但是转换...

    一、题目

    给你一个 32 位的有符号整数 x ,返回 x 中每位上的数字反转后的结果。

    如果反转后整数超过 32 位的有符号整数的范围 [ − 2 31 , 2 31 − 1 ] [−2^{31}, 2^{31} − 1] [231,2311] ,就返回 0。

    假设环境不允许存储 64 位整数(有符号或无符号)。
    在这里插入图片描述


    解析
    该题可以借助字符串实现,但是转换过程复杂而且效率低,所以通过数学的计算解决。

    • 通过循环将数字 x 的每一位拆开,计算新值时,每一步都判断是否溢出
    • 溢出的条件:大于整数的最大值 Integer.MAX_VALUE== 2 31 − 1 2^{31} − 1 2311 ,小于 Integer.MIN_VALUE == − 2 31 −2^{31} 231

    二、代码

    class Solution {
        public int reverse(int x) {
            int x_r = 0;
            while (x != 0) {
                int remainder = x % 10;
                //判断是否溢出
                //如果 x_r 和 Integer.MAX_VALUE/10 相等,且 remainder 大于7的话,那么两者和一定溢出
                if (x_r > Integer.MAX_VALUE / 10 || (x_r == Integer.MAX_VALUE / 10 && remainder > 7)) {
                    return 0;
                }
                if (x_r < Integer.MIN_VALUE / 10 || (x_r == Integer.MIN_VALUE / 10 && remainder < -8)) {
                    return 0;
                }
                x_r = x_r * 10 + remainder;
                x = x / 10;
            }
            return x_r;
        }
    }
    

    三、总结

    该题关键是对溢出的判断x_r > Integer.MAX_VALUE / 10成立的时候,那么 x_r * 10 一定溢出

    if (x_r > Integer.MAX_VALUE / 10 || (x_r == Integer.MAX_VALUE / 10 && remainder > 7)) {
          return 0;
    }
    if (x_r < Integer.MIN_VALUE / 10 || (x_r == Integer.MIN_VALUE / 10 && remainder < -8)) {
          return 0;
    }
    x_r = x_r * 10 + remainder;
    

    由于该题也可以使用 字符串解决,所以顺带复习下字符串的相关内容:

    //整数转为字符串
    String string = Integer.toString(a);
    //字符串转为字符数组
    char[] chars = string.toCharArray();
    //字符数组转为字符串
    String.valueOf(chars);
    //字符数组的复制
    Arrays.copyOfRange(chars, 0, chars.length);
    
    展开全文
  • 浅析 LeetCode_007_整数反转Java 实现)LeetCode_007_整数反转题目描述总体分析解决方案小结 LeetCode_007_整数反转 题目描述 给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。 示例 1: ...

    LeetCode_007_整数反转(Java 实现)

    LeetCode_007_整数反转


    题目描述

    给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。
    
    示例 1:
    
    输入: 123
    输出: 321
     示例 2:
    
    输入: -123
    输出: -321
    示例 3:
    
    输入: 120
    输出: 21
    注意:
    
    假设我们的环境只能存储得下 32 位的有符号整数,则其数值范围为 [−2^31,  2^31 − 1]。请根据这个假设,如果反转后整数溢出那么就返回 0。
    
    来源:力扣(LeetCode)
    链接:https://leetcode-cn.com/problems/reverse-integer
    著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。
    

    总体分析

    • 题目中要求将一个有符号整数进行反转,通过题目给出的例子,需要注意以下几点:
      1. 整数会有负数的情况,反转后符号不变。
      2. 只能存储 32 位有符号整数,取值范围为:-2147483648 ~ 2147483647。超过此范围即为溢出。如果反转后发生了溢出情况,返回 0。
      3. 要反转的数字最后一位是 0 的情况反转过来后要将 0 舍弃。
        • 如题目中的这个例子:120 --> 21。

    解决方案

    • 思路分析

      • 首先,先分析溢出问题,对于题目中要求的 32 位有符号整数,其实也就是 int 类型,相对应的取值范围为:-2147483648 ~ 2147483647。那么发生溢出的情况就是反转过来的数不在这个范围内。

        • 举个例子:将 2111222239 反转过来后为 9322221112,此时这个数超过了上面的范围,这个情况就是溢出,此时返回 0 即可。
      • 接着,分析转换的数是负数时的情况:如果要转换的数是负数,就先取其绝对值将其反转后再将结果转换为负数返回即可。

      • 综上,可以设计解题流程如下,假设要转换的数为 x:

        1. 首先判断 x 是否为 -2147483648,如果是返回 0,防止取 x 绝对值 -x 时报错。
        2. 判断 x 是否为负数,如果是负数则先取其绝对值然后递归取反,最后将结果转换为负数。
        3. 使用一个变量 result 保存结果,初始时为 0。
        4. 对 x 取反时将 x % 10 依次取出最后一位数(例如: 256 % 10 = 6)放置到 result 中(即 result * 10 + x % 10),最后将 x / 10。依次进行此过程即可将 x 反转。
        5. 在取反过程中需要注意的是要进行该判断:if (result > 214748364) 进行提前判断溢出处理。
          • 举个例子说明:
            • 1463847412 反转后为 2147483641,此时当反转到 214748364 时,还没有大于,所以没有溢出。如果 result > 214748364 说明反转后就已经溢出了。
            • 例如:1563847412 -> 2147483651,当反转到 214748365 时,由于大于了 214748364,所以可以提前判断溢出。
        6. 判断 result 是否溢出,如果溢出返回 0,否则返回反转后的结果,这里判断溢出是因为前面的提前判断溢出不能判断到最后一位,如果最后一位加的数超过溢出值的话就会产生溢出,所以需要判断。不好理解的话可以结合下面代码进行理解。
      • 根据以上思路,可设计题解代码如下:

        /**
         * 整数反转解题方案
         *
         * @author 踏雪彡寻梅
         * @date 2020/2/6 - 12:14
         */
        class Solution {
            public int reverse(int x) {
                if (x == -2147483648) {
                    // 做此判断防止取 x 绝对值时 x = -x 报错
                    return 0;
                }
        
                if (x < 0) {
                    // 如果为负数,取其绝对值调用自己然后将结果转为负数
                    return -reverse(-x);
                }
        
                // 用于保存结果返回
                int result = 0;
        
                // 取反操作
                while (x != 0) {
                    if (result > 214748364) {
                        // 处理溢出
                        // 举例:1463847412
                        // 反转后:2147483641
                        // 此时当反转到 214748364 时,还没有大于,所以没有溢出
                        // 如果 result > 214748364 反转后就已经溢出了
                        // 例如:1563847412 -> 2147483651
                        // 当反转到 214748365 时,由于大于了 214748364,所以可以提前判断溢出
                        return 0;
                    }
                    // 接收取反结果
                    result = result * 10 + x % 10;
                    x /= 10;
                }
        
                // 如果溢出就返回 0
                // 防止提前判断溢出不能判断到最后一位的情况,如果最后一位加的数超过溢出值的话就会产生溢出
                return result <= 2147483647 ? result : 0;
            }
        }
        
      • 提交结果
        在这里插入图片描述

      • 提交后时间上和空间上的结果还是效果蛮好的O(∩_∩)O。接下来进行一些简单的时间复杂度和空间复杂度分析。

      • 时间复杂度简单分析

        • 对于时间复杂度则是分析 while 循环中的代码,因为这块代码占据了程序的时间是最多的。

          while (x != 0) {
              if (result > 214748364) {
                  return 0;
              }
              result = result * 10 + x % 10;
              x /= 10;
          }
          
        • 从以上代码可以看出,x 每循环一次就除以 10,直到 x = 0 时或者 result 溢出时才结束循环。这里假设 result 不溢出的情况来进行分析:

          • 对于 x / 10 判断 x 是否等于 0 其实可以看为:x 除了几次 10 才等于 0。这里假设这个次数为 n。
            • 用式子表达也就是:x / 10 / 10 / 10 / … / 10 = x / 10n = 0,即可以表示为 x = 10n
          • 也就是说明,程序的运行时间主要跟 n 相关,所以需要将 n 计算出来:
            • 通过 x = 10n 求解 n 这个问题在高中时就已经学过了,即 n = log10x。
          • 所以,时间复杂度为 O(log10x) = O(lgx)。
      • 空间复杂度简单分析

        • 空间上使用了一个 result 整型变量用来辅助接收结果,每次赋值分配的空间都是常数级别的,所以空间复杂度为 O(1)。

    小结

    • 解题时需要注意特殊情况:为负数的情况、尾部为 0 的情况以及整数溢出的情况。

    如有写的不足的,请见谅,请大家多多指教。
    我的个人博客网站: www.xilikeli.cn 欢迎大家来访(#.#)


    展开全文
  • 给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转
  • 整数反转 java 给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。 示例 1: 输入: 123 输出: 321 示例 2: 输入: -123 输出: -321 示例 3: 输入: 120 输出: 21 注意: 假设我们的环境只能存储...
  • leetcode 7.反转整数JAVA

    千次阅读 2018-10-19 17:15:14
    给定一个 32 位有符号整数,将整数中的数字进行反转。 示例 1: 输入: 123 输出: 321  示例 2: 输入: -123 输出: -321 示例 3: 输入: 120 输出: 21 注意: 假设我们的环境只能存储 32 位有符号整数,...
  • leetcode 整数反转

    2021-03-26 21:45:41
    如果反转整数超过 32 位的有符号整数的范围[−231,231− 1] ,就返回 0。 假设环境不允许存储 64 位整数(有符号或无符号)。 二、示例 三、示例代码 代码: class Solution { public int reverse(int...
  • 给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。 示例1: 输入: 123 输出: 321 示例 2: 输入: -123 输出: -321 示例 3: 输入: 120 输出: 21 注意: 假设我们的环境只能存储得下 ...
  • 给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。 假设我们的环境只能存储得下 32 位的有符号整数,则其数值范围为[−231,231− 1]。请根据这个假设,如果反转整数溢出那么就返回 0。 ...
  • 给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。 示例 1: 输入: 123 输出: 321 示例 2: 输入: -123 输出: -321 示例 3: 输入: 120 输出:21 注意:假设我们的环境只能存储得下 32 位的...
  • LeetCode 整数反转

    2020-07-26 16:54:25
    整数反转 题目描述 给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。 输入 输出 123 321 输入 输出 -123 -321 输入 输出 120 21 在这里插入代码片 class ...
  • https://leetcode-cn.com/problems/reverse-integer/ public int reverse(int x) { int temp = 0; int res = 0; while(x!=0){ temp = x % 10; x = x/10; ...
  • LeetCode007——反转整数

    千次阅读 2018-08-21 22:46:35
    我的LeetCode代码仓:https://github.com/617076674/LeetCode 原题链接:https://leetcode-cn.com/problems/reverse-integer/description/ 题目描述: 知识点:字符串,int类型,数学 思路一:用long类型变量...
  • 执行用时 :2 ms, 在所有 java 提交中击败了53.22%的用户 内存消耗 :33.5 MB, 在所有 java 提交中击败了80.84%的用户 代码和注释 class Solution { public int reverse(int x) { int tmp = x; int revs = ...
  • 整数反转: 给出一个32位的有符号整数,你需要将这个整数中每位上的数字进行反转。 思路: 首先判断是否超界,超界就返回 0 不超界就装成字符串,再转字符数组,前后颠倒,再转回去输出 注意点:原先数不超界...
  • LeetCode整数反转

    2018-11-30 20:08:13
    给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。 示例 1: 输入: 123 输出: 321  示例 2: 输入: -123 输出: -321 示例 3: 输入: 120 输出: 21 注意: 假设我们的环境只能存储...
  • 给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。 示例 1: 输入: 123 输出: 321 示例 2: 输入: -123 输出: -321 示例 3: 输入: 120 输出: 21 注意: 假设我们的环境只能存储得下 32 位的有符号...
  • public boolean isPalindrome(int x) { String reversedStr = (new StringBuilder(x + "")).reverse().toString(); return (x + "").equals(reversedStr); }
  • LeetCode测试用例时发现会出现溢出的情况,考虑将temp换成long类型的数据在进行比较。 public static int reverse(int x) { long temp = 0; while (x != 0) { temp = temp * 10 + x % 10; x = x / 10; } ...
  • 给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。 示例1: 输入: 123 输出: 321 示例 2: 输入: -123 输出: -321 示例 3: 输入: 120 输出: 21 解法烂的一批,直接看第二个吧 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,655
精华内容 1,462
关键字:

leetcode整数反转java

java 订阅