从字符串处理到分治优化：大整数乘法的5种实现方式对比（附C代码）

最新推荐文章于 2026-08-22 12:49:15 发布

原创最新推荐文章于 2026-08-22 12:49:15 发布 · 631 阅读

本内容遵循CC 4.0 BY-SA版权协议

从字符串处理到分治优化：大整数乘法的5种实现方式对比（附C代码）

当我们在日常编程中处理两个int或long long类型的数字相乘时，几乎不会遇到任何障碍。然而，一旦数字的位数超过了语言内置数据类型所能表示的范围，比如需要计算两个1000位十进制数的乘积，常规的乘法操作就会立刻失效。这时，我们就需要踏入大整数乘法的领域。这不仅是算法竞赛中的经典问题，更是密码学、科学计算、金融系统等高性能计算场景下的基石技术。理解不同的实现方式，不仅仅是掌握几种代码写法，更是对计算效率、资源消耗和问题建模能力的深度训练。

本文将带你深入五种主流的大整数乘法实现方案，从最直观的“竖式模拟”到效率卓越的“分治策略”，再到结合具体场景的优化技巧。每种方法我都会附上可直接编译运行的C语言代码，并剖析其背后的时间复杂度、空间开销以及适用场景。无论你是正在备战技术面试的开发者，还是对算法优化有浓厚兴趣的学习者，这篇文章都将为你提供一套完整的、可实操的解决方案。

1. 基础：模拟手算竖式乘法

当我们第一次学习乘法时，老师教的就是竖式计算。将一个大数的每一位与另一个大数的每一位相乘，然后错位相加。用程序模拟这个过程，是最直接、最易于理解的大整数乘法实现方式。

大整数通常以字符串形式输入，例如 "123456789"。我们需要先将字符串反转，让个位存储在数组下标0的位置，这样处理进位会更加方便。核心算法是两层循环：外层遍历乘数A的每一位，内层遍历乘数B的每一位。乘积会累加到结果数组的 i+j 位置上。

注意：结果数组的初始长度至少应为 len(A) + len(B)，因为两个n位数相乘，结果最多为 2n 位。

下面是一个清晰的实现示例。代码中，num1 和 num2 是已经反转并转换为整型的数组，result 用于存储中间结果和最终答案。

void gradeSchoolMultiply(int num1[], int len1, int num2[], int len2, int result[]) {
    // 初始化结果数组为0
    for (int i = 0; i < len1 + len2; i++) {
        result[i] = 0;
    }

    for (int i = 0; i < len1; i++) {
        int carry = 0; // 每处理乘数A的一位，进位清零
        for (int j = 0; j < len2; j++) {
            int temp = result[i + j] + num1[i] * num2[j] + carry;
            result[i + j] = temp % 10; // 当前位结果
            carry = temp / 10;         // 进位
        }
        // 处理内层循环结束后可能的剩余进位
        if (carry > 0) {
            result[i + len2] += carry;
        }
    }
}

时间复杂度分析：该方法需要两层嵌套循环，如果两个大整数的位数分别为 m 和 n，则时间复杂度为 O(m * n)。当两个数位数相同时，即为 O(n²)。

优点与局限：

优点：逻辑极其简单，不易出错，是验证其他算法正确性的“黄金标准”。
局限：效率低下。当位数达到数千甚至上万时，计算时间会变得非常长，无法满足高性能需求。

2. 优化：Karatsuba分治算法

1960年，Anatolii Karatsuba提出了一种基于分治思想的大整数乘法算法，将时间复杂度从 O(n²) 降低到了约 O(n^1.585)，这是一个巨大的飞跃。其核心思想是“用加法换乘法”，因为加法的时间复杂度是 O(n)，远低于乘法。

假设有两个大数 X 和 Y，我们将其各自拆分为高低两部分：

X = A * 10^(n/2) + B
Y = C * 10^(n/2) + D

那么，X * Y = AC * 10^n + (AD + BC) * 10^(n/2) + BD。直接计算需要4次乘法（AC, AD, BC, BD）。Karatsuba的巧妙之处在于，它发现 (A+B)(C+D) = AC + AD + BC + BD，因此 AD + BC = (A+B)(C+D) - AC - BD。

这样，我们只需要计算三次乘法：

AC
BD
(A+B)(C+D)

然后通过加减法组合出最终结果。这个过程可以递归进行，直到数字小到可以直接计算（比如小于某个阈值）。

Karatsuba算法的C语言递归实现框架：

// 假设已有将大数转换为结构体或数组并支持加法、减法和幂运算的基础函数
BigInt karatsubaMultiply(BigInt x, BigInt y) {
    int n = max(x.length, y.length);

    // 基准情况：如果数字足够小，使用常规乘法
    if (n <= THRESHOLD) {
        return gradeSchoolMultiply(x, y);
    }

    // 分割数字
    int m = n / 2;
    BigInt high1, low1 = split(x, m);
    BigInt high2, low2 = split(y, m);

    // 递归计算三个乘积
    BigInt z0 = karatsubaMultiply(low1, low2);
    BigInt z1 = karatsubaMultiply(add(low1, high1), add(low2, high2));
    BigInt z2 = karatsubaMultiply(high1, high2);

    // 组合结果: z2 * 10^(2m) + (z1 - z2 - z0) * 10^m + z0
    BigInt part1 = shiftLeft(z2, 2 * m);
    BigInt part2 = shiftLeft(subtract(subtract(z1, z2), z0), m);
    BigInt result = add(add(part1, part2), z0);

    return result;
}

性能对比表格：

乘法方法	时间复杂度	理论计算量 (n=1024位)	适用场景
竖式模拟	O(n²)	~1,048,576 次单位乘	教学、验证、位数极少时
Karatsuba	O(n^log₂3) ≈ O(n^1.585)	~59,000 次递归乘运算	通用中等规模大数乘法
Toom-Cook	O(n^logₖ(2k-1))	比Karatsuba更优	更大规模（数千位）
FFT-based	O(n log n)	最优，但常数项大	超大规模（数万位以上）

提示：在实际编码中，递归的基准情况 THRESHOLD 需要仔细选择。如果设置过大，分治的优势无法体现；设置过小，递归开销会抵消性能收益。通常通过实验确定，在几十到几百位之间。

3. 进阶：Toom-Cook 算法

当数字规模继续增大时，Karatsuba的优化程度就显得不够了。Toom-Cook算法是Karatsuba的泛化形式。Karatsuba是将数字分成2部分，而Toom-Cook可以分成k部分（k=3时称为Toom-3）。

其基本步骤可以概括为：

分割：将每个大数分成k个较小的部分。
求值：为每个部分选择一组点（通常是小的整数），计算多项式在这些点上的值。
逐点相乘：在每一个选定的点上，将两个多项式对应的值相乘。
插值：利用相乘后的点值，通过插值还原出结果多项式的系数。
重组：将多项式系数组合成最终的大整数结果。

Toom-3算法的时间复杂度约为 O(n^log₃5) ≈ O(n^1.465)，比Karatsuba更快，但实现也复杂得多，涉及大量的线性代数运算（求解方程组）。它通常用于位数在几千到几万之间的乘法。

实现要点：

需要实现大数的加法、减法、乘法和除法（除以小整数）。
插值过程需要求解一个线性方程组，通常使用预计算的矩阵逆来加速。
代码复杂，调试困难，但它是通往更高级算法（如FFT）的重要阶梯。

4. 高效：基于FFT的Schönhage–Strassen算法

对于天文数字级别的大整数乘法（例如数百万甚至数十亿位），目前已知最实用的最优算法是基于快速傅里叶变换的Schönhage–Strassen算法（SSA）。

其核心思想是将大整数视为多项式，多项式的系数就是整数的各位数字。两个大整数相乘，等价于两个多项式相乘。而多项式乘法在时域是卷积操作，计算复杂度为O(n²)。但通过FFT，我们可以将多项式转换到频域，在频域中乘法是逐点相乘，复杂度为O(n)，然后再通过逆FFT变换回时域。FFT和逆FFT的复杂度是O(n log n)。

因此，整个算法的时间复杂度为 O(n log n log log n)。对于极大的n，这比任何前述算法都要快得多。

一个简化的基于FFT的大数乘法步骤：

补零与分组：将两个大数按一定基数（如10^4）分组，并补零使长度变为2的幂次，方便FFT计算。
FFT变换：对两个序列分别执行FFT，得到它们的频域表示。
频域相乘：将两个频域序列逐点相乘。
逆FFT：对相乘后的频域序列执行逆FFT，得到时域的卷积结果（即乘积的各位）。
进位处理：将逆FFT得到的序列进行进位规范化，得到最终的大整数。

// 伪代码示意，实际实现需要完整的复数FFT或数论变换(NTT)库
void multiplyViaFFT(BigInt a, BigInt b, BigInt &result) {
    int n = 1;
    while (n < a.len + b.len) n <<= 1; // 扩展为2的幂

    ComplexArray A = convertToComplexArray(a, n);
    ComplexArray B = convertToComplexArray(b, n);

    fft(A, n); // 快速傅里叶变换
    fft(B, n);

    for (int i = 0; i < n; i++) {
        A[i] *= B[i]; // 频域逐点相乘
    }

    inverseFft(A, n); // 逆变换

    // 将A中的实数部分取整，并处理进位
    handleCarry(A, result);
}

注意：直接使用复数浮点FFT会存在精度问题，当数字极大时舍入误差可能导致错误。因此，生产级的大数库（如GMP）通常使用数论变换，它在模素数域上进行，没有精度损失。

5. 实战：综合选择与C代码实现示例

了解了各种算法后，关键问题是如何选择。这没有绝对答案，取决于你的具体需求：数字的位数范围、对精度的要求、以及开发时间成本。

选择策略参考：

位数 < 100：直接使用竖式模拟法。代码简单，且在这个规模下，高级算法的递归或预处理开销可能反而使其更慢。
100 ≤ 位数 < 10,000：Karatsuba算法是绝佳选择。它在实现复杂度和性能之间取得了很好的平衡。你可以设定一个阈值（如80位），当数字小于阈值时回退到竖式乘法。
10,000 ≤ 位数 < 1,000,000：考虑实现Toom-3或更高级的Toom-Cook算法。虽然复杂，但性能提升显著。
位数 ≥ 1,000,000：应该使用基于FFT/NTT的算法。这是专业大数库（如GMP, LibTomMath）处理超大数乘法的标准方式。

下面给出一个完整的、可运行的Karatsuba算法C语言示例，它直接处理字符串输入，并包含了必要的辅助函数（大数加法、减法、移位和比较）。

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

// 大数结构体：动态数组存储数字（低位在前）
typedef struct {
    int *digits;
    int length;
    int capacity;
} BigInt;

// 一系列辅助函数：初始化、加法、减法、打印等（此处省略详细实现）
// ...

// Karatsuba 乘法核心函数
BigInt karatsuba(const BigInt *x, const BigInt *y) {
    int n = (x->length > y->length) ? x->length : y->length;

    // 基准情况：小数字直接用简单乘法
    if (n < 32) {
        return gradeSchoolMultiply(x, y);
    }

    // 使n为偶数，方便分割
    n = (n + 1) / 2;

    // 分割x和y为高位和低位
    BigInt high1, low1;
    BigInt high2, low2;
    splitBigInt(x, n, &high1, &low1);
    splitBigInt(y, n, &high2, &low2);

    // 递归计算z2, z0, z1
    BigInt z2 = karatsuba(&high1, &high2);          // z2 = high1 * high2
    BigInt z0 = karatsuba(&low1, &low2);           // z0 = low1 * low2

    BigInt sum1 = addBigInt(&high1, &low1);        // high1 + low1
    BigInt sum2 = addBigInt(&high2, &low2);        // high2 + low2
    BigInt z1 = karatsuba(&sum1, &sum2);           // z1 = (high1+low1)*(high2+low2)

    // 计算 middle = z1 - z2 - z0
    BigInt temp = subtractBigInt(&z1, &z2);
    BigInt middle = subtractBigInt(&temp, &z0);

    // 组合结果: z2 * 10^(2n) + middle * 10^n + z0
    BigInt part1 = shiftLeft(&z2, 2 * n);
    BigInt part2 = shiftLeft(&middle, n);
    BigInt result = addBigInt(&part1, &part2);
    result = addBigInt(&result, &z0);

    // 释放临时变量内存
    freeBigInt(&high1); // ... 释放其他临时变量
    return result;
}

int main() {
    char strX[1000], strY[1000];
    printf("请输入两个大整数（用空格分隔）:\n");
    scanf("%s %s", strX, strY);

    BigInt a = stringToBigInt(strX);
    BigInt b = stringToBigInt(strY);

    BigInt product = karatsuba(&a, &b);

    printf("乘积为: ");
    printBigInt(&product);
    printf("\n");

    freeBigInt(&a);
    freeBigInt(&b);
    freeBigInt(&product);
    return 0;
}

在实际项目中，内存管理、负数处理、输入验证等都是必须考虑的细节。这个示例框架展示了Karatsuba算法的核心逻辑。你可以在此基础上，根据前面章节的讨论，实现gradeSchoolMultiply作为基准，并尝试调整递归阈值来获得最佳性能。对于真正严肃的应用，研究并集成像GMP这样的成熟库通常是更可靠的选择，它们已经集成了从Karatsuba到SSA的全套优化算法，并经过了数十年的测试和优化。

标签