#7.整数反转-------简单

链接地址：https://leetcode-cn.com/problems/reverse-integer/solution/

题目：

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

示例 1:
输入: 123
输出: 321

示例 2:
输入: -123
输出: -321

示例 3:
输入: 120
输出: 21

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

代码：

这里我用的是jdk里的StringBuilder和Integer完成的，虽然使用栈push和pop也可以。

class Solution {
    public int reverse(int x) {
      
            int a=x>0?x:(0-x);
            StringBuilder tmp =new StringBuilder(Integer.toString(a));
           
            tmp=tmp.reverse();

            try {
                int result=x>0?Integer.parseInt(tmp.toString()):(0-Integer.parseInt(tmp.toString()));

                return result;
            }catch (Exception e){

                return 0;
            }
        
    }  
}

这里看一段StringBuilder里的reverse()代码：

    public AbstractStringBuilder reverse() {
        boolean hasSurrogates = false;
        int n = count - 1;
        for (int j = (n-1) >> 1; j >= 0; j--) {
            int k = n - j;
            char cj = value[j];
            char ck = value[k];
            value[j] = ck;
            value[k] = cj;
            if (Character.isSurrogate(cj) ||
                Character.isSurrogate(ck)) {
                hasSurrogates = true;
            }
        }
        if (hasSurrogates) {
            reverseAllValidSurrogatePairs();
        }
        return this;
    }

官方答案：

思路
  我们可以一次构建反转整数的一位数字。在这样做的时候，我们可以预先检查向原整数附加另一位数字是否会导致溢出。
算法
  反转整数的方法可以与反转字符串进行类比。我们想重复“弹出” x 的最后一位数字，并将它“推入”到 rev 的后面。最后，rev 将与 x 相反。

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

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

为了防止溢出，这里需要做判断。
  如果 temp = rev⋅10+pop 导致溢出，那么一定有 rev≥ INTMAX/10 。
  如果 rev> INTMAX/10，那么 temp=rev⋅10+pop 一定会溢出。
  如果 rev== INTMAX/10，那么只要 pop>7，emp=rev⋅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;
    }
}

复杂度分析

  时间复杂度：O(log(x))，x 中大约有log10(x) 位数字。
  空间复杂度：O(1)。