【LeetCode題解】7_反轉整數

【LeetCode題解】7_反轉整數

描述

給定一個 32 位有符號整數，將整數中的數字進行反轉。

示例 1:

輸入: 123
輸出: 321

示例 2:

輸入: -123
輸出: -321

示例 3:

輸入: 120
輸出: 21

注意:

假設我們的環境只能存儲 32 位有符號整數，其數值範圍是 $[-2^{31},\,2^{31} - 1]$。根據這個假設，如果反轉後的整數溢出，則返回 0。

方法一

思路

輸入的整數除以 10 得到商和餘數，接着將返回的結果（初始值爲 0）乘以 10 加上得到的餘數作爲新的結果，最後判斷結果是否溢出（大於 32 位整數的最大值或者小於 32 位整數的最小值），將商作爲新的整數重複上述過程，如果商爲 0 則程序結束。

可以將求整數逆序數的過程想象成兩個棧之間的彈出和壓入操作。一個整數的每一位數存放在棧的每一格中，最高位存放在棧底，最低位存放在棧頂。將棧 A 的棧頂彈出，壓入棧 B 的棧底，重複上述過程直到棧 A 爲空，此時就完成了求整數逆序數的功能。實際中，彈出和壓入操作並不需要藉助真正的棧，可以通過求餘（數學運算）實現。

其實，Python 語言的整數類型的取值範圍並不存在限制，因此更不存在所謂的溢出。

Java 實現

class Solution {
    public int reverse(int x) {
        long result = 0;
        while (x != 0) {
            result = result * 10 + x % 10;
            x = x / 10;
            if (result < Integer.MIN_VALUE || result > Integer.MAX_VALUE) {
                return 0;
            }
        }
        return (int) result;
    }
}
// Runtime: 23 ms
// Your runtime beats 77.34 % of java submissions.

複雜度分析：

• 時間複雜度：$O(log(n))$
• 空間複雜度：$O(1)$

類似的 Java 實現

class Solution {
	public int reverse(int x) {
        int ret = 0;
        while (x != 0) {
            int pop = x % 10;
            if (ret > Integer.MAX_VALUE / 10 || (ret == Integer.MAX_VALUE / 10 && pop > 7)) {
                return 0;
            }
            if (ret < Integer.MIN_VALUE / 10 || (ret == Integer.MIN_VALUE / 10 && pop < -8)) {
                return 0;
            }
            ret = ret * 10 + pop;
            x = x / 10;
        }
        return ret;
	}
}
// Runtime: 21 ms
// Your runtime beats 99.21 % of java submissions.

複雜度分析同上。

Python 實現

class Solution:
    def reverse(self, x):
        """
        Arguments:
        ----------
        x : int, the value range is [-2147483648, 2147483647]

        Return:
        -------
        ret : int, the reverse order number
        """
        rev, a = 0, abs(x)
        while a:
            rev = rev * 10 + a % 10
            a = a // 10
        if x > 0 and rev < 2**31:
            return rev
        elif x < 0 and rev <= 2**31:
            return -rev
        else:
            return 0
        
# Runtime: 56 ms
# Your runtime beats 85.51 % of python3 submissions.

複雜度分析同上。

方法二：轉化爲求字符串的倒序

Java 實現

class Solution {
    public int reverse(int x) {
        if (x == 0) {
            return 0;
        }

        boolean isPos = x > 0;

        StringBuilder sb = new StringBuilder();
        char[] chars = String.valueOf(x).toCharArray();
        for (int i = chars.length - 1; i >= 0; --i) {
            if (chars[i] == '0' && sb.length() == 0) {
                continue;
            }
            if (chars[i] == '-') {
                continue;
            }
            sb.append(chars[i]);
        }

        String xStr = null;
        if (isPos) {
            xStr = sb.toString();
        } else {
            xStr = "-" + sb.toString();
        }

        int rev;
        try {
            rev = Integer.valueOf(xStr);
        } catch (Exception e) {
            return 0;
        }
        return rev;
    }
}

複雜度分析：

• 時間複雜度：$O(log(n))$
• 空間複雜度：$O(1)$

Python 實現

class Solution:
    def reverse(self, x):
        """
        Arguments:
        ----------
        x : int, the value range is [-2147483648, 2147483647]

        Return:
        -------
        ret : int, the reverse order number
        """
        sign = [1, -1][x < 0]
        rev = sign * int(str(abs(x))[::-1])
        return rev if -2**31 <= rev <= 2**31 - 1 else 0

# Runtime: 76 ms
# Your runtime beats 42.26 % of python3 submissions.

複雜度分析同上。