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)

总结

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