Algorithm——整数反转

一、问题

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

示例 1:
输入: 123
输出: 321
 
示例 2:
输入: -123
输出: -321

示例 3:
输入: 120
输出: 21

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

二、解决

（堆栈方法）

/**
 * @param {number} num
 * @return {number}
 */
var reverse = function(num) {
        //转换成string
        var str = num.toString()
        //判断首字母符号
        var arr = str.split('')
        var rStr = '', rArr = []
        //判断首字母的符号
        if(isNaN(arr[0])) { 
            //true,不是数字，则隔离保留符号
            rArr = (arr.splice(1)).reverse().join('')
            rStr = arr[0] + rArr
        } else {
            //false,无符号直接转换
            rStr = (arr).reverse().join('')
        }

        //判断是否溢出
        if(Math.abs(parseInt(rStr)) > Math.pow(2,31) - 1) {
            //溢出
            return 0
        } else {
            //否则返回反转值
            return parseInt(rStr)
        }    
};

 （数学方法）

int reverse(int x) {
    int a=0;
    int i,j;
    long long int test=0;//长整型64位
    int num = x;
    long int nums[20];   //长
    if(x >= 2147483647 || x <= -2147483648) test = 0;
    else{
        if(num<0) x = -x;
        while(x>0)////计算整数有几位
        {
            nums[a] = x%10;
            x = x/10;
            a++;
        }
        for(i=0;i<a;i++)
        {
            for(j=a;j>i+1;j--)
            {
                nums[i] *= 10;
            }
            test += nums[i];
        }
        if(test > 2147483647 || test < -2147483648) test = 0;
        if(num<0) test = -test;
    }
    return test;
}

ps.数学方法的用时要比调用堆栈快很多。