一道简单的算法题--整数反转的一些记录

首先是题干

给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。
假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−231, 231 − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。

我首先想到的就是字符串的相关操作，于是头也不回地写出了以下的代码

public class Demo {
	public static int reverse(int x) {
		// 判断是否溢出
		if (x < Integer.MAX_VALUE && x > Integer.MIN_VALUE) {
			// 转化为字符串，进行进一步操作
			String str = x + "";
			String newStr = "";
			// 判断是否为负数
			if (x < 0) {
				str = str.substring(1, str.length());
				newStr = dofun(str);
				newStr = "-" + newStr;
			} else {
				newStr = dofun(str);
			}
			// 转换回整形
			// 判断反转后是否超出范围
			double test = Double.parseDouble(newStr);
			if (test > Integer.MAX_VALUE || test < Integer.MIN_VALUE) {
				return 0;
			}
			int result = Integer.parseInt(newStr);
			return result;
		}
		return 0;
	}

	public static String dofun(String str) {
		String newStr = "";
		// 置换
		for (int i = str.length(); i > 0; i--) {
			newStr += str.charAt(i - 1);
		}
		// 判断最高位是否为0
		while (newStr.charAt(0) == 0) {
			// 是，无视该位
			newStr = newStr.substring(1, str.length());
		}
		return newStr;
	}

	public static void main(String[] args) {
		int result = reverse(1534236469);
		System.out.println(Integer.MAX_VALUE);
		System.out.println(result);
	}
}

长达50行的代码，虽然实现了功能，但也显得过于繁琐。其实，对于整数的反转，只需要通过简单的算法知识便可解答。
对于每一位，我们可以通过

//reverse为输入的数
x =  reverse%10;
reverse = reverse/10;

的循环，就可以得到每一位的数字，然后通过

result = rev * 10 + x;

便可得到反转的数据，实际上，这是一个pop与push的过程。
不过，值得注意的是，result = rev * 10 + x是有可能溢出的。
如果rev == Integer.MAX_VALUE/10时，result就会溢出。
int类型的最大值为2147483647，也就是x>7。
而对于最小值2147483648，可知x<-8,综上，写出以下程序

class Demo02{
    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;
    }
}

相比原来的代码简单了很多。

学习算法的道路依旧很长…