超长正整数的加法_长整型的加法运算-CSDN博客

本文链接：https://blog.csdn.net/qq_41256535/article/details/139484463

一、引言

在计算机科学中，整数加法是一个基础且重要的操作。然而，当面对超长正整数（即超出计算机内置整数类型表示范围的整数）时，传统的整数加法方法便不再适用。超长正整数通常使用字符串或数组来表示，每一位对应整数的一个数字。因此，实现超长正整数的加法就需要一些特殊的技巧和算法。本文将详细探讨如何实现超长正整数的加法，并提供C++代码示例。

二、算法设计

超长正整数的加法算法可以借鉴手工进行大数加法的思路。具体步骤如下：

从最低位（即字符串的末尾或数组的尾部）开始，逐位相加。
将每一位的加法结果（0-18）分为两部分：进位（0或1）和当前位的值（0-9）。
将进位加到下一位的加法结果中，并重复步骤2，直到所有位都处理完毕。
如果最高位仍有进位，需要在结果前添加一个数字“1”。
转换回字符串或数组形式，得到最终的加法结果。

三、C++代码实现

下面是一个使用C++实现的超长正整数加法的示例代码：

#include <iostream>
#include <string>
#include <algorithm>

// 辅助函数：将两个数字相加并返回结果和进位
std::pair<int, int> addDigits(int a, int b, int &carry) {
    int sum = a + b + carry;
    carry = sum / 10;
    return {sum % 10, carry};
}

// 超长正整数加法函数
std::string addBigNumbers(const std::string &num1, const std::string &num2) {
    // 反转字符串以便从最低位开始相加
    std::string reversedNum1 = num1;
    std::string reversedNum2 = num2;
    std::reverse(reversedNum1.begin(), reversedNum1.end());
    std::reverse(reversedNum2.begin(), reversedNum2.end());

    // 确保num1是较长的数
    if (reversedNum2.size() > reversedNum1.size()) {
        std::swap(reversedNum1, reversedNum2);
    }

    // 初始化结果字符串和进位
    std::string result;
    int carry = 0;

    // 逐位相加
    for (size_t i = 0; i < reversedNum1.size(); ++i) {
        int digit1 = reversedNum1[i] - '0';
        int digit2 = (i < reversedNum2.size()) ? (reversedNum2[i] - '0') : 0;
        auto [sumDigit, newCarry] = addDigits(digit1, digit2, carry);
        result.push_back(sumDigit + '0');
        carry = newCarry;
    }

    // 处理最高位的进位
    if (carry > 0) {
        result.push_back(carry + '0');
    }

    // 反转结果字符串并返回
    std::reverse(result.begin(), result.end());
    return result;
}

// 主函数
int main() {
    std::string num1, num2;
    std::cout << "请输入第一个超长正整数：";
    std::cin >> num1;
    std::cout << "请输入第二个超长正整数：";
    std::cin >> num2;

    std::string sum = addBigNumbers(num1, num2);
    std::cout << "两数之和为：" << sum << std::endl;

    return 0;
}

四、代码解释

addDigits函数：这是一个辅助函数，用于将两个数字和一个进位相加，并返回结果和新的进位。
addBigNumbers函数：这是实现超长正整数加法的核心函数。首先，它反转输入的两个字符串，以便从最低位开始相加。然后，它遍历较短的字符串（或两个字符串中的每一位），逐位相加，并使用addDigits函数处理进位。最后，它处理最高位的进位（如果有的话），并反转结果字符串以得到正确的顺序。
main函数：这是程序的主入口。它首先接收用户输入的两个超长正整数，然后调用addBigNumbers函数计算它们的和，并输出结果。

五、性能优化与边界情况处理

在实现超长正整数的加法时，除了基本的算法设计外，我们还需要考虑一些性能优化和边界情况的处理。

1. 性能优化

预分配内存：在构建结果字符串时，我们可以预先估计结果字符串的长度，并一次性分配足够的内存空间。这样可以避免在添加新字符时频繁地重新分配内存，从而提高性能。
避免不必要的字符串反转：在上面的示例代码中，我们对输入字符串进行了两次反转操作（一次是为了从最低位开始相加，另一次是为了得到正确的结果顺序）。我们可以优化这个步骤，只进行一次反转操作，即在生成结果字符串时直接按照正确的顺序添加字符。

2. 边界情况处理

空字符串或零值：当输入字符串为空或表示零值时，我们需要特殊处理。例如，如果两个输入字符串都是空字符串或表示零值，则结果也应该是一个空字符串或表示零值。
前导零：在生成结果字符串时，我们可能需要删除前导零。虽然前导零在数学上不影响整数的值，但在某些应用中可能需要将它们删除以获得更简洁的表示。

3. 错误处理

非法输入：我们应该确保输入字符串只包含有效的数字字符。如果输入包含非数字字符，我们应该能够检测并处理这种错误情况。
溢出处理：虽然超长正整数的加法本身不会导致溢出（因为我们可以使用任意长度的字符串或数组来表示结果），但在某些情况下，我们可能需要处理与超长正整数加法相关的溢出问题。例如，当我们试图将结果存储在一个固定长度的变量中时，可能会发生溢出。在这种情况下，我们应该能够检测并处理这种错误情况。

4. 示例代码优化

下面是一个优化后的示例代码，它包含了上述提到的一些改进：

#include <iostream>
#include <string>
#include <stdexcept>

// 辅助函数：将两个数字相加并返回结果和进位
std::pair<int, int> addDigits(int a, int b, int &carry) {
    int sum = a + b + carry;
    carry = sum / 10;
    return {sum % 10, carry};
}

// 超长正整数加法函数（优化版）
std::string addBigNumbers(const std::string &num1, const std::string &num2) {
    if (num1.empty() && num2.empty()) {
        return "0"; // 如果两个数都是空字符串，则返回"0"
    }

    // 确保num1是较长的数
    std::string maxNum = num1;
    std::string minNum = num2;
    if (num2.size() > num1.size()) {
        std::swap(maxNum, minNum);
    }

    int carry = 0;
    std::string result;
    int i = maxNum.size() - 1, j = minNum.size() - 1;

    // 逐位相加
    while (i >= 0) {
        int digit1 = i >= 0 ? maxNum[i] - '0' : 0; // 处理maxNum的剩余位数
        int digit2 = j >= 0 ? minNum[j] - '0' : 0; // 处理minNum的剩余位数
        auto [sumDigit, newCarry] = addDigits(digit1, digit2, carry);
        result.push_back(sumDigit + '0');
        carry = newCarry;
        --i;
        --j;
    }

    // 处理最高位的进位
    if (carry > 0) {
        result.push_back(carry + '0');
    }

    // 去除前导零（如果有的话）
    while (!result.empty() && result.front() == '0') {
        result.erase(0, 1);
    }

    return result;
}

// 主函数（略）
// ...