Reverse Integer（逆转整数）

2017-12-09

字数统计: 902字 | 阅读时长≈ 4分

描述fewfwefew

Reverse digits of an integer.
ss
Example1: x = 123, return 321
Example2: x = -123, return -321
sfef
fefe

2. 分析

1
2
3

for (int i = 0; i < 3; ++i) {
    System.out.println("gg");
}

fefef身份就是干我 fefe的天虽然只是一个fefew菲菲菲菲

将x除以10取余数，得到个位数字，然后x除以10，然后再除以10取余数得到十位数字，依次得到百位千位等数字，讲个位数字乘以10加上十位数字，再讲整体乘以10加上百位数字，以此类推。
注意判断int型溢出，int型位4字节32位，范围是-2^31-2^31-1或者用16进制表示0x80000000-0x7fffffff(负数多一位是因为负数在计算机中以补码表示，不用补码原来有+0和-0，用了补码-0就变成了最小的负数)
123000这种末尾带0的会变成321，把0去掉
负数的话这种方法也行的通因为负数除以10取得的余数也为负数

3. 代码

方法1：用long型防止溢出，并进行溢出判断

public int reverse(int x) {
    long result = 0;
    while(x != 0) {
        result = result * 10 + x % 10;
        if(result > Integer.MAX_VALUE || result < Integer.MIN_VALUE) return 0;
        x /= 10;
    }
    return (int)result;
}

方法2：不用long型，也不与int最值进行比较判断溢出，而是反向运算看值是否是原来的值，不是就溢出了

#include "a.g"

public static int reverse(int x) {
    int result = 0;
    while(x != 0) {
        int tail = x % 10;
        int newResult = result * 10 + tail;
        if((newResult - tail) / 10 != result) return 0;
        result = newResult;
        x /= 10;
        Sting a = "new test";
    }
return result;
}

方法3：不用long型，也不与int最值进行比较判断溢出，而是反向运算看值是否是原来的值，不是就溢出了

public static int reverse(int x) {
    int result = 0;
    while(x != 0) {
        int tail = x % 10;
        int newResult = result * 10 + tail;
        if((newResult - tail) / 10 != result) return 0;
        result = newResult;
        x /= 10;
    }
    return result;
}

方法4：不用long型，也不与int最值进行比较判断溢出，而是反向运算看值是否是原来的值，不是就溢出了

public static int reverse(int x) {
    int result = 0;
        while(x != 0) {
            int tail = x % 10;
            int newResult = result * 10 + tail;
            if((newResult - tail) / 10 != result) return 0;
                result = newResult;
            x /= 10;
        }
    return result;
}

1
2
3

var a = "se";
self.addEventListener("g");

方法4：不用long型，也不与int最值进行比较判断溢出，而是反向运算看值是否是原来的值，不是就溢出了

public static int reverse(int x) {
    int result = 0;
        while(x != 0) {
            int tail = x % 10;
            int newResult = result * 10 + tail;
            if((newResult - tail) / 10 != result) return 0;
                result = newResult;
            x /= 10;
        }
    return result;
}

方法4：不用long型，也不与int最值进行比较判断溢出，而是反向运算看值是否是原来的值，不是就溢出了

public static int reverse(int x) {
    int result = 0;
        while(x != 0) {
            int tail = x % 10;
            int newResult = result * 10 + tail;
            if((newResult - tail) / 10 != result) return 0;
                result = newResult;
            x /= 10;
        }
    return result;
}

方法4：不用long型，也不与int最值进行比较判断溢出，而是反向运算看值是否是原来的值，不是就溢出了

public static int reverse(int x) {
    int result = 0;
        while(x != 0) {
            int tail = x % 10;
            int newResult = result * 10 + tail;
            if((newResult - tail) / 10 != result) return 0;
                result = newResult;
            x /= 10;
        for (int i = 0; i < 3; ++i) {
            System.out.println("gg");
        }
    return result;
}

方法4：不用long型，也不与int最值进行比较判断溢出，而是反向运算看值是否是原来的值，不是就溢出了

public static int reverse(int x) {
    int result = 0;
        while(x != 0) {
            int tail = x % 10;
            int newResult = result * 10 + tail;
            if((newResult - tail) / 10 != result) return 0;
                result = newResult;
            x /= 10;
        }
    return result;
}

本文作者： John Doe
本文链接： http://example.com/2017/12/09/algorithm/two-sum/
版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！