整数反转（java）

• 问题

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

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

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

• 解题思路

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;
    }
}

先把官方解题思路放出来，省的误导别人hiahia~~

        依次将该整数的个位pop取出来，像栈一下，再推入rev中，在此过程中，要判断是否溢出，这也是困惑我的点。

因为每次循环过程中，x都是/10之后的数据，所以这里也要比较下是否大于Integer.MAX_VALUE/10,若两个数值相等，要比较个位数是否比Integer.MAX_VALUE的个位数7大，这样就能比较出来是否比最大数大，最小数同理。

Integer.MAX_VALUE：2147483647

Integer.MIN_VALUE：-2147483648

循环次数	pop	x	rev * 10 + pop
1	7	156384	7
2	4	15638	74
3	8	1563	748
4	3	156	7483
5	6	15	74836
6	5	1	748365
7	1	0	7483651

•  我的思路

看到答案只有几行的时候，我觉得我的简直是相形见绌。为了纪念下我的算法成长之旅，还是贴出来吧~

      我想的是，将这个数据，以map<位置，位置上的数字>记录下来，然后循环这个整数的长度/2,这样先取出第一个map.get(0),乘以10的（xLength-j-1）次方，再将对应的（xLength-j-i）位置的值取出来，乘以10的j次方。

看似思路也还可以，但实际情况中，要在很多地方加上是否溢出的判断，也要判断是否是正负数，增加了一些逻辑。

我的误区：sum+=a1+a2,三个数都是int类型，当a1和a2相加溢出时，并不会返回一个真正正确的值，所以我看了好一会儿为什么sum值总是不对。

1(1)	7(8)
2(5)	6(4)
3(6)	5(7)
4(3)

 

public static int reverse(int x) {
        try {
            if (x > Integer.MAX_VALUE || x < Integer.MIN_VALUE) {
                return 0;
            }

            int xTemp1 = x;
            // 若是负数，则将其暂时设为正数，因为后面要存每个数值到map中
            if (x <= 0) {
                x = x *(-1);
            }
            int xTemp2 = x;
            Map<Integer, Integer> map = new HashMap();
            int i = 0;
            while (xTemp2 != 0) {
                map.put(i, xTemp2 % 10);
                xTemp2 /= 10;
                i++;
            }
            int xLength = (x + "").length();
            long sum = 0;
            for (int j = 0; j < xLength / 2; j++) {
                 // 这里只是判断有没有溢出
                if (map.get(j) * Math.pow(10, xLength - j - 1) > Integer.MAX_VALUE ||
                        map.get(j) * Math.pow(10, xLength - j - 1) < Integer.MIN_VALUE) {
                    return 0;
                }
                if (map.get(xLength - j - 1) * (int) Math.pow(10, j) > Integer.MAX_VALUE ||
                        map.get(j) * Math.pow(10, xLength - j - 1) < Integer.MIN_VALUE) {
                    return 0;
                }
                // 重点在这
                int a1 = map.get(j) * (int) Math.pow(10, xLength - j - 1);
                int a2 = map.get(xLength - j - 1) * (int) Math.pow(10, j);
                sum += a1 + a2;
                if (sum > Integer.MAX_VALUE || sum < Integer.MIN_VALUE) {
                    return 0;
                }
            }
            //奇数的数字个数
            if (xLength % 2 == 1) {
                int a3 = map.get(xLength / 2) * (int) Math.pow(10, xLength / 2);
                sum += a3;
                if (sum > Integer.MAX_VALUE || sum < Integer.MIN_VALUE) {
                    return 0;
                }
            }
            if (xTemp1 <= 0) {
                sum *= (-1);
            }
            if (sum > Integer.MAX_VALUE || sum < Integer.MIN_VALUE) {
                return 0;
            }
            return (int) sum;
        } catch (Exception e1) {
            return 0;
        }
    }