LeetCode中Reverse Integer

这只是我学习记录用的，不要太较真。

Reverse Integer是我做的第二个LeetCode算法题
- Reverse digits of an integer.
- Example1: x = 123, return 321
- Example2: x = -123, return -321
- The input is assumed to be a 32-bit signed integer. Your function should return 0 when the reversed integer overflows.
- 输入假定为32位有符号整数。当反转的整数溢出时，您的函数应返回0。

---

目录

用 [TOC]来生成目录：

主要思路

网上有许多种答案，一种是先转化成字符串，然后进行逆序；一种是从最后一位开始取，每取得一个数n，把n放在新数sum的最后一位，同时证明之前得到的数sum都要向前进一位，即sum=sum*10+n。

我的主要思路是，先确定数字的长度，然后交换两边位置。
例如：12345，取得1和5交换位置，即：sum = sum + 1*1+5*1000。

代码一

从个位开始统计数字长度。

            long i = 1;
            long sum = 0;
            long sum1 = 0;
            long sum2 = 0;
            long a = 0;
            long b = 0;
            if(x==0){
                return x;
            }
            for(;;i=i*10){    //找到x的最高位（统计长度）
                if(x/i == 0) break;
            }
            i = i/10;         //得到第一位数，如：12345 最高位：10000，而i此时为100000
            for(int j=1;i>=j;j=j*10,i=i/10){
                a = x/i;      //当取第二位时，得到a=12
                sum1 = a % 10;//得到第二位 2
                b = x/j;
                sum2 = b % 10;
                if(i==j){    //对于长度为基数时，进行此判断。
                    sum = sum + sum1*j;
                    break;
                }
                sum = sum + sum1*j + sum2 * i;
            }
            if (sum> Integer.MAX_VALUE || sum < Integer.MIN_VALUE){//判断是否溢出
                return 0;
            }
            return (int)sum;

代码二

从第一位开始统计数字长度。

        int i = 1000000000;
        long sum = 0;
        long sum1 = 0;
        long sum2 = 0;
        int a = 0;
        int b = 0;
        if(x==0){
            return x;
        }
        for(;i>=1;i=i/10){
            if(x/i != 0) break;
        }
        for(int j=1;i>=j;j=j*10,i=i/10){
            a = x/i;
            sum1 = a % 10;
            b = x/j;
            sum2 = b % 10;
            if(i==j){
                sum = sum + sum1*j;
                break;
            }
            sum = sum + sum1*j + sum2 * i;
            if (sum> Integer.MAX_VALUE || sum < Integer.MIN_VALUE){
                return 0;
            }
        }
        return (int)sum;

不用考虑正负号，因为正负号对结果没有影响。

总结

我这种思想，会发生很极端的现象，比如第一个代码，如果x取10 0000 0000，则会造成计算最高位时，就已经很耗时了，而第二个代码，如果x取1，同样也会很耗时。

我在想，如果把两段代码放在一起，首先用10 0000对x进行判断，如果x大于这个数用第二个代码，如果x小于这个数用第一个代码。