2021.08.30 - 002.整数反转

1. 题目

2. 思路

(1) 字符串反转法

• 由于最大值与最小值的绝对值不同，且最小值有负号，因此需要分别讨论大于0和小于0的情况。
• 利用StringBuilder类的append()，从后向前遍历原数字的字符串，即可得到反转后的新数字绝对值的字符串。
• 判断是否溢出只需判断数字长度是10位的情况：从前向后依次遍历每一位数字，若某一位的值大于最大值对应位的值，则判断溢出，直接返回0；若某一位的值小于最大值对应位的值，则判断不溢出，直接结束循环；若某一位的值等于最大值对应位的值，则继续向后判断。

(2) 数学法

• 原数字%10即可得到末位的数字，新数字*10+原数字末位的数字即可实现数字从原数字的末位出栈到新数字的末位入栈，实现反转。
• 在最后一次循环中，有可能出现新数字*10+原数字末位的数字溢出的情况，因此需要先判断新数字运算后是否会溢出。

3. 代码

public class Test {
    public static void main(String[] args) {
        Solution solution = new Solution();
        System.out.println(solution.reverse(-12345678));
    }
}

class Solution {
    public int reverse(int x) {
        if (x == 0) {
            return 0;
        }
        String unsignedValue;
        String unsignedMax;
        StringBuilder reverseValue = new StringBuilder();
        if (x > 0) {
            unsignedValue = String.valueOf(x);
            unsignedMax = String.valueOf(Integer.MAX_VALUE);
        } else {
            unsignedValue = String.valueOf(x).substring(1);
            unsignedMax = String.valueOf(Integer.MIN_VALUE).substring(1);
        }
        //反转字符串
        for (int i = unsignedValue.length() - 1; i >= 0; i--) {
            reverseValue.append(unsignedValue.charAt(i));
        }
        unsignedValue = reverseValue.toString();
        //判断是否溢出
        if (unsignedValue.length() == unsignedMax.length()) {
            for (int i = 0; i < unsignedValue.length(); i++) {
                if (Integer.parseInt(unsignedValue.substring(i, i + 1)) > Integer.parseInt(unsignedMax.substring(i, i + 1))) {
                    return 0;
                } else if (Integer.parseInt(unsignedValue.substring(i, i + 1)) < Integer.parseInt(unsignedMax.substring(i, i + 1))) {
                    break;
                }
            }
        }
        if (x > 0) {
            return Integer.parseInt(unsignedValue);
        } else {
            return -Integer.parseInt(unsignedValue);
        }
    }
}

class Solution1 {
    public int reverse(int x) {
        int result = 0;
        while (x != 0) {
            if (result > Integer.MAX_VALUE / 10 || result < Integer.MIN_VALUE / 10) {
                return 0;
            }
            //从原数字的末位出栈到新数字的末位入栈，先进后出，实现反转
            result = result * 10 + x % 10;
            x /= 10;
        }
        return result;
    }
}