整數反轉-算法詳細分析

題目：整數反轉：

給出一個 32 位的有符號整數，你需要將這個整數中每位上的數字進行反轉。

示例 1:

    輸入: 123
    輸出: 321

示例 2:

    輸入: -123
    輸出: -321

示例 3:

    輸入: 120
    輸出: 21

注意:
假設我們的環境只能存儲得下 32 位的有符號整數，則其數值范圍為 [−2^31, 2^31 − 1]。
請根據這個假設，如果反轉后整數溢出那么就返回 0。

 import java.math.BigInteger;
 
 /**
 
  * @author cosefy
  * @date 2020/6/9
    */
    public class ReverseInt {
    public static void main(String[] args) {
        int num = -153254269;
        int res1 = reverse_Test1(num);
        int res2 = reverse_Test2(num);
        System.out.println("解法一結果是： " + res1);
        System.out.println("解法二結果是： "+res2);
    }

解法一

思路：利用數學特性去做，每次對10取余，數字逐漸整除10，新結果=原結果*10+余數。
分析：時間復雜度與數的位數有關系，O（log x）
易錯點：
-一個是負數問題，注意循環判別條件
-注意溢出問題，

public static int reverse_Test1(int x) {
    long result = 0;
    while (x != 0) {
        int temp = x % 10;
        x = x / 10;
        result = result * 10 + temp;
    }
    if(result > 2147483647 || result < -2147483648)
        return 0;
    else
        return (int)result;
}

解法二

思路：就是通過數字轉換成字符串，然后從最后一個字符從后向前添加，達到翻轉的效果。

分析：時間復雜度為數字的長度，會用到一定的輔助空間。

易錯點：注意本解法容易出現的NumberFormatException異常。

  public static int reverse_Test2(int num) {
        if (num == 0 || num > 2147483647 || num < -2147483648)
            return 0;
        int temp = num>0?num:-num;
        String s = String.valueOf(temp);
        StringBuffer chars = new StringBuffer();
        for (int i = s.length() - 1; i >= 0; i--) {
            chars.append(s.charAt(i));
        }
        //System.out.println(Integer.valueOf(chars.toString()));
        long result = 0;
        if(chars.toString()==null)
            return 0;
       /* BigInteger integer = new BigInteger(chars.toString());
        System.out.println(integer);*/
        try{
            result =  Integer.parseInt(chars.toString());
        }catch (Exception e){
            return 0;
        }
        result = num>0?result:-result;
        if(result > 2147483647 || result < -2147483648)
            return 0;
        else
            return  (int) result;
        
    }
}