LeetCode刷题日记（7. 整数反转）

7.整数反转

int reverse(int x) {
    if (x == 0) return x;
    // 之所以单独处理这个是因为此时-x溢出了会报错
    if (x == -2147483648) return 0;

    int neg, num;
    neg = x < 0 ? -1 : 1;
    num = x < 0 ? -x : x;

    int N = (int)log10(num) + 1;  // 位数
    int *arr = calloc(N, sizeof(int));
    for(int i=0; i<N; i++) {
        arr[i] = num % 10;
        num /= 10;
    }
    
    if (N == 10 && arr[0] > 2) return 0;

    int res = 0, factor = 1;
    for (int i=0; i<N; i++) {
        res += (factor * arr[N-1-i]);
        if (i < N-1)  factor *= 10;
        
        if (N == 10 && i == 8 && neg == 1 && (res > 147483647)) return 0;
        if (N == 10 && i == 8 && neg == -1 && (res > 147483648)) return 0;
    }
    return res * neg;
}

题目比较简单，关键在于要考虑到所有的溢出情况，我都是靠着报错来对溢出情况进行判定，在一开始基本都没考虑到。

还有就是对于边界值怎么判断，因为题目假设环境不允许存储 64 位整数（有符号或无符号），我的处理方法是：先把数拆开保存在数组中，然后分步判断。2^31=2,147,483,648，先获取数的位数（ 获取一个数的位数），再获取每一位的数字，如果是10位数那么他就有可能溢出，先判断第一位是否大于2，大于2直接返回，如果等于2就先计算后9位数字对应的值，判断该值是否大于147,483,647（负数时为大于147,483,648），如果大于直接返回，否则就没有溢出。

应该要考虑的溢出情况：

1、1534236469，反转后9>2，溢出

2、-2147483648，反转后溢出

3、-2147483412，反转后 147483412 > 147483647

还有一些未考虑到的错误：因为题目假设环境不允许存储 64 位整数，因此编写的代码中的临时变量也不应该超过这个范围，之前没有考虑到报错了。

别人家的代码

int reverse(int x) {
    int rev=0;
    while(x!=0)
    {
        if(rev>INT_MAX/10||rev<INT_MIN/10)
        {
            return 0;
        }
        rev=rev*10+x%10;
        x/=10;
    }
    return rev;
}

另一个

int reverse(int x){
int res = 0;
        while(x!=0) {
            //每次取末尾数字
            int tmp = x%10;
            //判断是否 大于 最大32位整数
            if (res>214748364 || (res==214748364 && tmp>7)) {
                return 0;
            }
            //判断是否 小于 最小32位整数
            if (res<-214748364 || (res==-214748364 && tmp<-8)) {
                return 0;
            }
            res = res*10 + tmp;
            x /= 10;
        }
        return res;
    }

我一开始有个疑惑，为什么第一个没有判断最后一位是否大于7（或小于-8），后来我想明白了，因为这个最后一位是输入的第一位，如果输入是合法的，那么即使是最大输入（2^31），开头也不过是2，肯定不会超过8的，因此不需要再判断了。

INT_MAX 和 INT_MIN 是在<limits.h>中定义的，表示编译器中的最大最小值。

别人的这两种算法基本一样，都是将数字从末尾一位一位的取，取完之后再直接计算当前的结果，然后在计算之前判断结果是否溢出。简洁明了，可谓是最佳解法了。