力扣第7题：解密整数反转的奥秘

前端

2024-01-04 16:47:21

整数反转：深入解析其本质与技巧

拨开迷雾，探寻整数反转的奥秘

在计算机科学的广阔天地中，整数反转是一项基础且常见的操作，它要求我们将一个给定的整数（有符号或无符号）颠倒其数字顺序。乍看之下，这似乎是一项简单的任务，但其中隐藏着一些微妙的细节和技巧，值得我们深入探索。

整数反转的本质：化繁为简

为了透彻理解整数反转的精髓，我们需要从其本质入手。本质上，整数反转可以归结为以下三个关键步骤：

数字提取： 将给定整数的每个数字逐个提取出来，并存储在适当的数据结构中，如数组或链表。
位置颠倒： 对提取出的数字进行位置颠倒，即将最右边的数字移动到最左边，依次类推。
数字重组： 将位置颠倒后的数字重新组合成一个新的整数，并返回该整数作为反转后的结果。

揭秘整数反转的多种算法

理解了整数反转的本质之后，我们就可以探索多种不同的算法来实现这个操作。以下是几种常见且高效的整数反转算法：

字符串操作法： 这种方法将给定整数转换为字符串，然后使用字符串的反转函数或算法来反转字符串，最后将反转后的字符串重新转换为整数。
除余法： 这种方法利用除法和取余运算来逐个提取整数的数字，并将这些数字存储在一个数组中。然后，再利用数组的特性将数字重新组合成反转后的整数。
递归法： 这种方法利用递归的思想来实现整数反转。首先，将整数的最后一位数字提取出来，并将其作为反转后的整数的末尾。然后，对剩余的整数进行递归调用，并将反转后的结果与最后一位数字组合起来，得到最终的整数反转结果。

代码实现：将理论付诸实践

为了加深读者对整数反转算法的理解，这里将提供几种不同语言的代码实现，供读者参考和实践。

Python：

def reverse_integer(x):
    """
    反转一个给定的整数。

    :param x: 给定的整数
    :type x: int
    :raises TypeError: 如果给定的值不是整数
    :raises ValueError: 如果给定的整数超过 32 位有符号整数的范围
    :returns: 反转后的整数
    :rtype: int
    """

    # 检查输入是否有效
    if not isinstance(x, int):
        raise TypeError("输入值必须是整数")
    if x < -2**31 or x > 2** 31 - 1:
        raise ValueError("输入值超出 32 位有符号整数的范围")

    # 将整数转换为字符串
    x_str = str(abs(x))

    # 反转字符串
    reversed_str = x_str[::-1]

    # 将反转后的字符串重新转换为整数
    reversed_int = int(reversed_str)

    # 处理正负号
    if x < 0:
        reversed_int = -reversed_int

    return reversed_int

JavaScript：

const reverseInteger = (x) => {
    // 检查输入是否有效
    if (typeof x !== 'number') {
        throw new TypeError('输入值必须是数字');
    }

    // 将整数转换为字符串
    const xString = Math.abs(x).toString();

    // 反转字符串
    const reversedString = xString.split('').reverse().join('');

    // 将反转后的字符串重新转换为整数
    const reversedInteger = parseInt(reversedString, 10);

    // 处理正负号
    if (x < 0) {
        reversedInteger = -reversedInteger;
    }

    return reversedInteger;
};

Java：

public class ReverseInteger {

    public static void main(String[] args) {
        int x = 123;
        System.out.println("反转前的整数： " + x);
        int reversedInteger = reverse(x);
        System.out.println("反转后的整数： " + reversedInteger);
    }

    public static int reverse(int x) {
        // 检查输入是否有效
        if (x < Integer.MIN_VALUE || x > Integer.MAX_VALUE) {
            throw new IllegalArgumentException("输入值超出 32 位有符号整数的范围");
        }

        // 将整数转换为字符串
        String xString = String.valueOf(Math.abs(x));

        // 反转字符串
        char[] reversedChars = xString.toCharArray();
        int left = 0;
        int right = reversedChars.length - 1;
        while (left < right) {
            char temp = reversedChars[left];
            reversedChars[left] = reversedChars[right];
            reversedChars[right] = temp;
            left++;
            right--;
        }

        // 将反转后的字符串重新转换为整数
        String reversedString = String.valueOf(reversedChars);
        int reversedInteger = Integer.parseInt(reversedString);

        // 处理正负号
        if (x < 0) {
            reversedInteger = -reversedInteger;
        }

        return reversedInteger;
    }
}

C++：

#include <iostream>
#include <string>

using namespace std;

int reverseInteger(int x) {
    // 检查输入是否有效
    if (x < INT_MIN || x > INT_MAX) {
        throw invalid_argument("输入值超出 32 位有符号整数的范围");
    }

    // 将整数转换为字符串
    string xString = to_string(abs(x));

    // 反转字符串
    reverse(xString.begin(), xString.end());

    // 将反转后的字符串重新转换为整数
    int reversedInteger = stoi(xString);

    // 处理正负号
    if (x < 0) {
        reversedInteger = -reversedInteger;
    }

    return reversedInteger;
}

int main() {
    int x = 123;
    cout << "反转前的整数： " << x << endl;
    int reversedInteger = reverseInteger(x);
    cout << "反转后的整数： " << reversedInteger << endl;

    return 0;
}