LeetCode初级算法之字符串：7 整数反转

整数反转

题目地址：https://leetcode-cn.com/problems/reverse-integer/

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

示例 1:

输入: 123
输出: 321

示例 2:

输入: -123
输出: -321

示例 3:

输入: 120
输出: 21

注意:

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

解法一：暴力解法

主体

1. 整数转字符串

2. 字符串的反转

3. 字符串转整数

边界

• 数值溢出边界：溢出返回0

细节

• 首位不为0
• 符号处理

public int reverse(int x) {
	//1.整数转字符串
    String str = "" + x;
    char[] s = str.toCharArray();
    //2.字符串的反转
    int n = s.length;
    for(int i = 0; i < n/2; i++){
        char temp = s[i];
        s[i] = s[n-i-1];
        s[n-i-1] = temp;
    }
    //3.字符串转整数
    //Integer result = Integer.valueOf(String.valueOf(array));
    long value  = Long.valueOf(String.valueOf(array));
    boolean b = value > Integer.MAX_VALUE || value < Integer.MIN_VALUE;
    int result = b ? 0 : (int)value;
    return result;
}

在上述代码中已经完成主体代码以及反转后的数值越出边界的问题，首位不为零问题：Integer将整数字符串转整数时会自动去掉前面如果有高位的0。那么还剩下符号处理整数x如果是-123，反转字符串是"321-"肯定是不能的。要把负号拿出来之后的数字参与主体过程，最后再把结果加上负号。

//拿走符号sign
int sign = x > 0 ? 1 : -1;
//剩下绝对值
x = x < 0 ? x * -1 : x;

让处理之后的x参与主体代码，最后返回值加上符号

return result * sign;

但上面拿绝对值的这个步骤是有问题的，因为最小值的绝对值是比最大值要大1的。当传入的int x = Integer.MIN_VALUE时绝对值超过了int的范围。因此在符号拿取之前先进行判断，把极值（包括最大值）直接返回掉毕竟它们反转之后数字大小一定是溢出没必要经过主体三步之后在判断是否返回0。

public int reverse(int x) {
    //极值筛掉
	if(x == Integer.MAX_VALUE || x == Integer.MIN_VALUE){
        return 0;
    }
    //符号处理
	int sign = x > 0 ? 1 : -1;
	x = x < 0 ? x * -1 : x;
	//1.整数转字符串
    String str = "" + x;
    char[] s = str.toCharArray();
    //2.字符串的反转
    int n = s.length;
    for(int i = 0; i < n/2; i++){
        char temp = s[i];
        s[i] = s[n-i-1];
        s[n-i-1] = temp;
    }
    //3.字符串转整数
    //Integer result = Integer.valueOf(String.valueOf(array));
    long value  = Long.valueOf(String.valueOf(s));
    boolean b = value > Integer.MAX_VALUE || value < Integer.MIN_VALUE;
    int result = b ? 0 : (int)value;
    //加上符号
    return result * sign;
}

时间复杂度O(n)，空间复杂度O(n)

解法二：数学思维

既然是把一个整数变成另外一个整数面对这样的问题的完全可以找到数学的方式，在数组里我们使用索引指针取各个值，在数字里面我们就可以用除法和取模运算来获取各个值。上面我们数组或者字符串直接拼接各个字符。这里我们就累加拼接。效率提升一个次元。

public int reverse(int x) {
    //极值筛掉
	if(x == Integer.MAX_VALUE || x == Integer.MIN_VALUE){
        return 0;
    }
    int result = 0;//返回结果
	int last = 0;//末位
    while((last = x % 10) != x){
        result = result * 10 + last;
        x /= 10;
    }
    //添加最后一位判断溢出
    long value = result;
    value = value * 10 + last;
    if(value > Integer.MAX_VALUE || value < Integer.MIN_VALUE){
        return 0;
    }else{
        result = (int)value;
    }
    return result;
}

时间复杂度O(n)，空间复杂度O(1)

总结

总体上是两种思路但可以优化的点还有一些比如个位判断直接返回等等，这里主要体会的是关于数字处理的相关算法都是可以采用数学方式，它是远远比操作字符效率要高。第二就是关于实现主体与细节、边界的一个划分，尽量降低耦合性。