LeetCode-反转整数

LeetCode-反转整数

LeetCode-反转整数

1 Easy-反转整数

1.1 题目描述

给定一个 32 位有符号整数，将整数中的数字进行反转。

1.2 示例 1:

输入: 123
输出: 321

1.3 示例 2:

输入: -123
输出: -321

1.4 示例 3:

输入: 120
输出: 21

1.5 注意:

假设我们的环境只能存储 32 位有符号整数，其数值范围是 [−\(2^{31}\), \(2^{31}\) − 1]。根据这个假设，如果反转后的整数溢出，则返回 0。

2 自己的答案

2.1 代码

package algorithm.easy;

import java.util.ArrayList;
import java.util.List;

public class ReverseInteger {
    public static int reverse(int x) {
        Long r = new Long(0);
        List<Integer> list = new ArrayList<Integer>();

        while(x != 0) {
            // 取最后一位数字
            list.add(x % 10);
            x /= 10;
        }

        for (int li : list) {
            r = r * 10 + li;
            if (r > Integer.MAX_VALUE || r < Integer.MIN_VALUE) {
                return 0;
            }
        }
        return r.intValue();
    }

    public static void main(String[] args) {
        System.out.println(reverse(2147483647));
    }
}

2.2 思路

  1. 总体想法: 将整型数的最后一位通过取余方式得出,并存储到一个动态数组中,然后通过遍历数组中的元素组成一个反转的数字

2.2.1 遇到的问题及解决办法

  1. 防止整型数反转的时候溢出: 使用了Long类型变量进行存储反转的结果,并在循环中判断Long的值是否超出32位整型数的范围

2.3 反思

  1. 在获得最后一位数字的的while循环里即可以通过临时变量直接构造出反转的整数,用List存储每一位数字是白白浪费了内存空间.
  2. 想法是正确的,但是编码水平仍需提升.

3 官方解答

  1. 方法：弹出和推入数字 & 溢出前进行检查

3.1 思路

  1. 我们可以一次构建反转整数的一位数字。在这样做的时候，我们可以预先检查向原整数附加另一位数字是否会导致溢出。

3.2 算法

反转整数的方法可以与反转字符串进行类比。

我们想重复“弹出” xx 的最后一位数字，并将它“推入”到 \(rev\) 的后面。最后，\(rev\) 将与 \(x\) 相反。

要在没有辅助堆栈 / 数组的帮助下 “弹出” 和 “推入” 数字，我们可以使用数学方法。 

//pop operation:
pop = x % 10;
x /= 10;

//push operation:
temp = rev * 10 + pop;
rev = temp;

但是，这种方法很危险，因为当 \(temp = rev \cdot 10 + pop\) 时会导致溢出。

幸运的是，事先检查这个语句是否会导致溢出很容易。

为了便于解释，我们假设 \(rev\) 是正数。

  1. 如果 \(temp = rev \cdot 10 + pop\) 导致溢出,那么一定有 \(rev \ge \frac{INTMAX}{10}\) .
  2. 如果 \(rev \gt \frac{INTMAX}{10}\) ,那么 $temp = \(rev \cdot 10 + pop\) 一定会溢出 .
  3. 如果 \(rev == \frac{INTMAX}{10}\) ,那么只要 \(pop > 7\) , \(temp = rev \cdot 10 + pop\) 就会溢出。

当 \(rev\) 为负时可以应用类似的逻辑。

  1. 如果 \(temp = rev \cdot 10 + pop\) 导致溢出,那么一定有 \(rev \le \frac{INTMAX}{10}\) .
  2. 如果 \(rev \lt \frac{INTMAX}{10}\) ,那么 \(temp = rev \cdot 10 + pop\) 一定会溢出 .
  3. 如果 \(rev == \frac{INTMAX}{10}\) ,那么只要 \(pop < -8\) , \(temp = rev \cdot 10 + pop\) 就会溢出。
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;
    }
}

3.3 复杂度分析

  1. 时间复杂度：$O(log(x))$，\(x\) 中大约有 \(\log_{10}(x)\) 位数字。
  2. 空间复杂度：$O(1)$。

Date: 2018-10-24 14:47

Author: devinkin

Created: 2018-10-24 三 15:33

Validate

posted @ 2018-10-24 14:53  EmacsDevinkin  阅读(666)  评论(0)  编辑  收藏  举报