高精度算法全解析：从大数加减乘除到工程实践

先给各位看个场景：某天同事跑过来说线上订单金额对不上了，0.1加0.2算出来不是0.3，最后查出来是double类型精度在那捣乱。还有一次做算法题，让算2的100次方，long long直接爆了，一脸懵。说白了一句话：系统自带的整数和浮点数，在真正的大数字和精确计算面前，撑不住。这时候就需要高精度算法——用数组把每一位数字都存下来，然后像小学做竖式一样，一步一步把加减乘除算出来。这篇东西就是想把高精度加减乘除算法这件事讲透，从最基础的表示方式，到加法减法乘法除法的完整实现，再到工程里怎么用BigDecimal、Julia之类的高精度类型，最后把那些容易踩的坑一并列出来。适合算法初学者、准备面试或者打比赛的同学，也适合业务开发中真遇到金额精度问题的朋友。

1. 为什么原生整数和浮点数撑不起"高精度"

1.1 先看两个让人头疼的真实例子

第一个例子是整型溢出。C++里最常用的64位有符号整数long long，最大值也就9223372036854775807，大概是9.2乘以10的18次方。你算个2^60还能扛住，但想算2^100就直接原地爆炸了。更别说金融系统里算天文数字、密码学里处理RSA大数，这种规模下原生整型完全不够看。

第二个例子是浮点数精度丢失。IEEE 754标准的double用二进制表示小数，但十进制小数转二进制经常是无限循环的，比如0.1。所以你在绝大多数编程语言里跑0.1+0.2，结果往往是0.30000000000000004，而不是0.3。这个误差在银行计息、电商结算、科学计算里都是灾难级的。别以为只有弱类型语言才这样，Java和C++照样中招。

1.2 高精度的核心思路：用数组把数字拆开存

高精度算法的思路其实特别朴素：既然原生类型装不下，那就别把它当成一个数，而是当成一串数字，每一个十进制位都单独存进数组里。你可以理解成"暴力但可靠"的方案，用空间换精度，用一个数组换来无限大的数值范围。

这个思路和硬件里的多精度运算很像。小学数学做竖式加法，从个位加到最高位，满十进一；做乘法，一个数每一位去乘另一个数的每一位，然后累加。高精度算法就是把"竖式"翻译成代码，所以它也叫大整数运算、多精度运算。你不需要任何花哨的数学知识，小学算术底子就够了。

1.3 高精度到底用在哪些地方

说几个常见场景，你就知道它不是竞赛专属玩具：

• 金融结算：金额必须精确到分，任何误差都不能接受，Java里用BigDecimal，Python里用decimal模块，底层就是高精度十进制运算。
• 密码学：RSA的密钥动辄1024位、2048位，本身就是超大整数，乘法和取模运算都是高精度操作。
• 科学计算：某些数值模拟需要上百位精度，Julia里的BigFloat、Python里的mpmath库就是干这个的。
• 算法竞赛：高精度加法、阶乘求和、大数快速幂，这些都是经典题型，很多省选和ACM题目里高精度是基础前置技能。
• 编译器与标准库：很多语言底层默认就用高精度整数，比如Python的int、Java的BigInteger内部实现。

2. 高精度加法与减法：从存储设计到进位借位

2.1 数字怎么存：倒序数组与长度字段

实现之前先把存储结构定下来。最经典的方案是用一个vector，每一位存一个十进制数字（0到9），并且倒序存储：数组下标0对应个位，下标1对应十位，以此类推。

为什么倒序？因为加减乘除都是从低位开始处理的，而且进位只会让数字长度增加。如果正序存储，进位要在数组头部插入元素，性能是O(n)的插入成本；倒序存储进位只需要push_back，平均O(1)。这个细节在数据量大时非常明显。

再配合一个长度字段或者直接取vector.size()，高精度数就表示完整了。读取时把字符串反过来，从高位到低位逐字符转换成数字，同时注意去掉前导零。

code复制#include <vector>
#include <string>
#include <algorithm>

using namespace std;

// 从字符串构造高精度数，去掉前导零
vector<int> fromString(const string& s) {
    vector<int> a;
    for (int i = (int)s.size() - 1; i >= 0; --i) {
        a.push_back(s[i] - '0');
    }
    // 去掉前导零，至少保留一位
    while (a.size() > 1 && a.back() == 0) a.pop_back();
    return a;
}

这里有个细节容易被忽略：如果输入是"000123"，直接循环读会把三个零都存进去，后面做减法比较大小的时候就会出问题。所以构造完一定要去前导零，同时保证至少保留一位，因为数字0本身也要能表示。

2.2 高精度加法的完整实现

加法是最基础的运算，逻辑就是竖式加法。从头到尾逐位相加，加上进位，得到当前位的结果，更新进位。最后循环结束如果还有进位，就再补一位。

code复制// 高精度加法：a + b
vector<int> add(const vector<int>& a, const vector<int>& b) {
    int n = max(a.size(), b.size());
    vector<int> c;
    int carry = 0;
    for (int i = 0; i < n; ++i) {
        int digitA = (i < a.size()) ? a[i] : 0;
        int digitB = (i < b.size()) ? b[i] : 0;
        int sum = digitA + digitB + carry;
        c.push_back(sum % 10);
        carry = sum / 10;
    }
    if (carry) c.push_back(carry);
    return c;
}

注意我在循环里用了一个三元表达式来处理两个数长度不一样的情况，短的数在超出范围后补0参与运算。这种做法比单独写两个循环要简洁，也好维护。进位carry一定是0或1，因为两个一位数相加再加上进位最大是9+9+1=19，不可能超过这个范围。

一个很容易出问题的地方是：如果a和b都是空数组怎么办。实际工程里不应该出现这种情况，但刷题时可能遇到，最好的对策是在构造时就保证vector里至少有一个元素，也就是数字0对应的"0"。

2.3 减法：先比大小，再逐位借位

减法比加法稍微麻烦一点，因为涉及大小比较和负数。核心思路：如果a >= b，直接算a - b；如果a < b，改算b - a，然后加个负号标记。

所以先写一个比较函数。高精度比较大小，先比长度，长度大的数肯定更大；如果长度一样，从最高位往低处逐位比较。

code复制// 比较：返回1表示a>b，0表示a==b，-1表示a<b
int compare(const vector<int>& a, const vector<int>& b) {
    if (a.size() != b.size()) {
        return a.size() > b.size() ? 1 : -1;
    }
    for (int i = (int)a.size() - 1; i >= 0; --i) {
        if (a[i] != b[i]) return a[i] > b[i] ? 1 : -1;
    }
    return 0;
}

然后再写减法。从低位开始，逐位相减，不够减就向高位借1，当前位加10，同时给下一位设置一个借位标记borrow。

code复制// 高精度减法：a - b，要求 a >= b
vector<int> subtract(const vector<int>& a, const vector<int>& b) {
    vector<int> c;
    int borrow = 0;
    for (int i = 0; i < (int)a.size(); ++i) {
        int digitA = a[i];
        int digitB = (i < b.size()) ? b[i] : 0;
        int diff = digitA - digitB - borrow;
        if (diff < 0) {
            diff += 10;
            borrow = 1;
        } else {
            borrow = 0;
        }
        c.push_back(diff);
    }
    while (c.size() > 1 && c.back() == 0) c.pop_back();
    return c;
}

这里因为借位是1不是10进制逻辑，所以借位后当前位加10，然后borrow置1。你可能注意到我最后又去了一次前导零——两个数相减可能结果位数变少，比如1000减999结果是1，如果不删掉后面的零，数组会存成1000的倒序加一，完全不对。这个去零操作在减法里是必须的。

调用方式就是外面先compare一下，根据大小关系决定是否交换顺序、是否需要输出负号。做题时可以把这两个函数组合成一个对外接口。

2.4 复杂度与压位优化

加法和减法的时间复杂度都是O(n)，n是数字位数。这个复杂度基本是下限了，因为每个位都得扫一遍。空间复杂度同样是O(n)，存结果。

不过你要是实际跑大数据量，会发现一个性能问题：每位只存0到9，一个100万位的数字，vector里就放了100万个int，每个int占4字节，光内存就是4MB。这还不算运算时的临时开销。所以实际场景里有个优化叫压位，也就是基底不用10，用10000，这样数组每一位可以存0到9999，代表原数的4个十进制位。这样位上能压到原来的四分之一，运算次数也少很多。

压位的代码改动很小，把模数和除数从10改成10000就行。但是打印输出时要特别小心，除了最高位那一段，其他的都需要用printf("%04d")或者手动补零，否则"10001"会被打印成"11"。这块很容易踩坑，后面实战部分我再细说。

3. 高精度乘法：竖式思想的复杂度陷阱与优化路径

3.1 朴素竖式乘法实现

乘法是加法的进阶版，思路还是模拟竖式。一个数的第i位去乘另一个数的第j位，结果会放在第i+j位。这样两层循环之后，每一位上可能积累了很大的值，最后统一处理进位。

code复制// 高精度乘法：a * b
vector<int> multiply(const vector<int>& a, const vector<int>& b) {
    vector<int> c(a.size() + b.size(), 0);
    for (int i = 0; i < (int)a.size(); ++i) {
        long long carry = 0;
        for (int j = 0; j < (int)b.size(); ++j) {
            long long cur = c[i + j] + (long long)a[i] * b[j] + carry;
            c[i + j] = cur % 10;
            carry = cur / 10;
        }
        c[i + b.size()] += carry;
    }
    while (c.size() > 1 && c.back() == 0) c.pop_back();
    return c;
}

这里有几个细节值得注意。第一，结果长度最大是a.size()+b.size()，所以初始化vector的时候直接开这个长度，避免多次push_back的动态扩容。第二，每一位相乘的结果可能突破int范围，所以用long long来接收。第三，进位不一定只有1，因为一个位上可能积累很多，比如999乘999，中间乘积接近100万，所以进位可能是个三位数。

我见过很多初学实现把进位处理放在第二层循环外，也就是先全部累加到一个c数组里，然后单独循环处理进位。那种做法也可以，但每个c[i]可能积累到非常大的数，需要在long long范围内才安全，而且会多遍历一遍。我推荐上面这种内层循环就处理进位的写法，性能更好，也直观。

3.2 为什么O(n^2)会卡死：位数增长分析

朴素乘法的复杂度是O(n^2)，因为两个数各n位，嵌套两层循环，总共n*n次乘法。听起来还好？那我们来算一笔账：

• 100位乘100位，1万次乘法，瞬间完成。
• 1000位乘1000位，100万次乘法，还能接受。
• 10000位乘10000位，1亿次乘法，这就开始慢了，C++里大概要跑零点几秒到几秒。
• 100000位乘100000位，100亿次乘法，直接跑不动了。

所以当你只是做一道竞赛题，数字在几百到几千位，朴素乘法完全够用。但你要是处理密码学里的2048位大数做模幂，或者科学计算里几个百万位的大数相乘，O(n^2)就是性能灾难。这时候就需要更快的乘法算法。

3.3 分治与FFT：大数乘法的性能跃迁

两个经典加速方案是Karatsuba算法和FFT/NTT。

Karatsuba算法的核心思想是分治。假设两个n位数x和y，把x拆成高位x1和低位x0，y拆成y1和y0，那么：

xy = (x1B + x0) * (y1B + y0) = x1y1B^2 + (x1y0 + x0*y1)B + x0y0

其中核心技巧是中间项不单独做两次乘法，而是用(x1+x0)(y1+y0)减去x1y1再减去x0*y0得到。这样原来4次n/2位数的乘法，变成了3次n/2位数的乘法加几次加法。递归下去，时间复杂度从O(n^2)降到O(n^1.585)。

FFT/NTT则更进一步，利用卷积定理，把大整数乘法看成两个序列的卷积，用快速傅里叶变换把乘法转换成点值域的逐点乘法，复杂度可以降到O(n log n)。不过FFT涉及浮点误差，NTT要用模数取模，实现复杂度高不少。工程里的Java BigInteger在超大数相乘时就会用这些高级算法，普通应用一般接触不到。

我自己的经验是这样的，贴个选型参考：

3.4 竞赛与工程中的实际选择

我对大多数人的建议是：先把朴素乘法写到滚瓜烂熟，因为它最简单、最不容易出错，适合绝大多数题目和业务场景。等真的遇到性能瓶颈，再考虑引入Karatsuba，因为它的实现相当巧妙地利用了代数恒等式，代码量也不算大，是性价比最高的优化。

如果你是在做Java或者Python开发，大部分时候直接用BigInteger或者int就好，底层库早就帮你做了各种优化。自己手写高精度乘法的主要场景反而是学习原理、算法竞赛和C/C++这类没有内置大整数的环境。

4. 高精度除法：整个算法族的硬骨头

4.1 高精度除以低精度：从高位往低位试商

高精度除以单精度（也就是除以一个普通int）是最简单的除法场景。思路是从最高位开始，逐位把当前余数乘10加上当前位，然后除以除数，得到商的当前位，余数留到下一位继续。

code复制// 高精度除以低精度：返回商，余数通过引用传出
vector<int> divideByInt(const vector<int>& a, int divisor, int& remainder) {
    vector<int> c(a.size(), 0);
    long long cur = 0;
    for (int i = (int)a.size() - 1; i >= 0; --i) {
        cur = cur * 10 + a[i];
        c[i] = cur / divisor;
        cur %= divisor;
    }
    remainder = (int)cur;
    while (c.size() > 1 && c.back() == 0) c.pop_back();
    return c;
}

注意这里必须从高位往低位遍历，和加法减法乘法都不一样。因为除法本质上是做多次减法，每次从高位拿一个数字下来补充余数。cur的类型用long long，因为cur * 10 + a[i]理论上可能超过int范围，虽然实际上只要除数在int范围内，cur最多也就是divisor的量级，保险起见用long long不会错。

有一点要特别提：因为循环结束时我是用while循环清理前导零，但注意这里的"前导零"指的是高位上的0，由于是倒序存储，实际上是指数组尾部多余的高位0。

4.2 高精度除以高精度：二分答案与模拟竖式

高精度除以高精度就难了。两个大整数相除，怎么得到商和余数？常见有两种思路。

第一种是二分答案。因为我们知道商一定在0到被除数之间，可以二分查找商的值，然后用乘法验证，找到最大的商使得商*除数 <= 被除数。这样每次验证需要O(n^2)的乘法，二分要O(log n)轮，总复杂度O(n^2 log n)，虽然不优但胜在简单可靠。

第二种是模拟竖式试商。也就是模拟手算除法：每次从被除数里取出一段，和除数比较，尝试找到一个数字q，使得q*除数不超过当前被除的那段。这个"试商"过程在二进制下只需要试0或1，在十进制下可能要试0到9，实现更复杂。

如果你在竞赛里遇到高精度除以高精度，我建议直接用二分答案，理由有三点：第一，实现简单，不容易写错；第二，配合已经写好且可信赖的高精度乘法和减法，逻辑清晰；第三，对于千位以内的数字，性能完全够用。

code复制// 高精度除以高精度：返回商和余数，使用二分答案
pair<vector<int>, vector<int>> divide(const vector<int>& a, const vector<int>& b) {
    // 先处理特殊情况：b为0直接报错
    vector<int> low(1, 0), high = a;
    while (compare(low, high) < 0) {
        vector<int> mid = add(low, high);
        // mid = (low + high) / 2
        // 注意这里除以2可以写成 divideByInt(mid, 2)
        vector<int> tmp;
        int rem;
        tmp = divideByInt(mid, 2, rem);
        vector<int> prod = multiply(tmp, b);
        if (compare(prod, a) <= 0) {
            low = add(tmp, vector<int>(1, 1)); // 二分需要mid+1，下一步换成
            // 这里其实要小心，使用low = tmp，但需要记录ans
        } else {
            high = tmp; // 注意这里需要减1
        }
    }
    // 完整实现略，核心就是用二分逼近商
}

上面代码只是示意，真正写的时候要小心边界条件。更简洁的做法是维护一个ans变量，每轮如果mid*k <= a成立，就ans = mid，low = mid + 1，否则high = mid - 1。这样最终的低边界high就是商，再用减法算出余数。由于代码较长，这里不展开全部，思路清楚了写起来就顺。

4.3 小数位：让结果精确到任意位

除法经常会遇到"除不尽"的情况，高精度算法的优势这时候就展露无遗：可以一直算下去，你想要多少位小数就能给多少位。原理很简单，整数除法算出余数之后，想求小数位，就把余数乘以10再除以除数，得到第一位小数，然后再取余数，再乘10，循环往复。

code复制// 计算 a/b 的小数点后 k 位
string decimalPart(const vector<int>& a, int b, int k) {
    string res;
    int remainder;
    vector<int> quotient = divideByInt(a, b, remainder);
    long long cur = remainder;
    for (int i = 0; i < k; ++i) {
        cur *= 10;
        res.push_back('0' + cur / b);
        cur %= b;
    }
    return res;
}

这种做法和周游列国的"长除法"一模一样。注意求小数的时候，前几位可能都是0，所以不能用普通的数字到字符串转换，必须一位一位地push_back。还有，如果要求四舍五入，那要多算一位，然后判断那位是否大于等于5来决定最后一位是否加一。

4.4 除法边界条件与注意事项

现实中的代码不会只跑理想情况，所以要处理几个边界：

• 除数为0：直接抛异常或者返回错误标志，绝不能静默返回0，否则后续计算全是错的。
• 被除数小于除数：商为0，余数为被除数本身。这个情况在compare里就能判断，不用走完整除法流程。
• 结果的前导零：和之前一样，商构造完要清理前导零。
• 负数处理：如果涉及负数，可以统一转成正数做除法，最后再根据符号决定是否加负号。这样实现最干净。

从业务角度说，这些边界条件往往是bug的高发区。我自己写过一次高精度计算模块，测试用例一开始只测常规数值，后来加入"除数为0""被除数为0""结果仅一位"这些边界用例，瞬间暴露了三个问题。所以调试的时候别嫌麻烦，把边界都测一遍。

5. 工程世界的高精度：BigDecimal、Julia BigInt 与实战注意

5.1 Java BigDecimal：做金额计算的标准答案

手写高精度算法是一回事，工程里直接用现成库是另一回事。Java里处理金额的标配就是BigDecimal。但有三个坑我必须说清楚。

第一个坑：初始化方式。new BigDecimal(0.1)会把double的二进制近似值完整还原成"0.1000000000000000055511151231257827021181583404541015625"，这根本不是你要的0.1。正确做法是new BigDecimal("0.1")或者BigDecimal.valueOf(0.1)，让字符串或valueOf内部帮你做正确转换。

第二个坑：除法必须指定精度。BigDecimal的divide方法如果除不尽，会直接抛ArithmeticException，因为默认要求结果是精确的。所以生产代码里基本都要写成a.divide(b, 10, RoundingMode.HALF_UP)，指定小数位10位和四舍五入模式。我见过不止一次线上事故就是漏了这个参数。

第三个坑：比较要用compareTo而不是equals。BigDecimal("1.0")和BigDecimal("1.00")的equals返回false，因为它们scale不同。而compareTo才会忽略末尾多余的0，按数学值比较。金额比较如果没注意这个，很容易出隐蔽bug。

5.2 Julia 的高精度整数和浮点数

再来看热词里提到的Julia。Julia语言原生支持BigInt和BigFloat，用起来比C++顺手太多。算2的200次方这种大数，一句话就搞定。

code复制using Base.GMP

# 高精度整数
x = big(2)^200
println(x)

# 高精度浮点数
y = BigFloat(1) / BigFloat(3)
println(y, " precision = ", precision(y))

Julia的BigFloat可以设置精度，默认大概256位二进制精度，还能通过setprecision调整。对于科学计算和数值验证来说很方便，你不需要手动管理进位借位，语言底层全处理好了。不过你要是想理解原理，还是建议自己用C++写一遍高精度加减乘除，这种"从零造轮子"的体验能帮你建立起非常牢固的底层直觉。

5.3 高精度与快速幂：计算超大幂次的经典组合

高精度算法和快速幂算法经常一起出现。常见的题目是"求2的1000次方"或者"计算N的阶乘"。快速幂的思路是把指数按二进制拆分，用平方来减少乘法次数，但每一步的乘法都是大数乘法。

这里贴一个思路伪代码，把高精度乘法和快速幂结合起来：

code复制// 快速幂：base^exp，base是高精度数，exp是int
vector<int> power(vector<int> base, int exp) {
    vector<int> result{1};  // 结果初始化为1
    while (exp > 0) {
        if (exp % 2 == 1) {
            result = multiply(result, base);  // 当前二进制位为1，乘上base
        }
        base = multiply(base, base);          // base平方
        exp /= 2;
    }
    return result;
}

这套模板可以解决大量涉及大数幂次的题目。比如求2^1000，直接调power(fromString("2"), 1000)，秒钟出结果。在此基础上再扩展出大数取模，就是幂模运算，RSA的底层操作，思路完全一样，只是每次乘完取个模。

5.4 从实践中踩过的坑

写高精度算法，我踩过的坑比写普通算法多得多。归纳几个最典型的：

第一，前导零没清理干净。这个问题在加减乘除里反复出现。尤其减法，1000 - 999 = 1，如果不到位清理前导零，数组可能存成"0001"的反向形式，后面比较大小全乱套。

第二，压位输出时没补零。用基底10000压位后，打印时要对中间位补零。举个例子，数字100000001，压位存储是[1, 0, 1]（倒序），如果直接从头到尾用cout输出，会打出"101"，而实际应该是"100000001"。所以打印函数要单独处理，最高位直接输出，之后每一位都要printf("%04d")。

第三，符号和负数。减法里的符号处理如果放到函数内部，会让比较和后续运算变复杂。我的做法是统一在内部用绝对值做计算，外层调用时判断大小，单独输出负号。这样各函数职责单一，不容易互相影响。

第四，性能预估不足。有些人觉得高精度就是能算，不管复杂度。实际上，如果乘法不做任何优化，算两个一万位的数相乘都要跑很久。遇到大数，先估算位数，再决定要不要上Karatsuba，别一上来就写个O(n^2)然后抱怨慢。

5.5 后续还能扩展的方向

高精度加减乘除是底子，底子打好了还能往这些方向走：高精度平方根（可以用牛顿迭代配合高精度除法）、高精度取模与扩展欧几里得（RSA相关）、高精度进制转换、高精度三角函数（用高精度浮点模拟）。大多数情况下，业务开发直接用现成库，但理解原理能帮你判断什么时候该用哪个库、怎么设置参数、出了问题怎么排查。

最后再分享一个我个人的习惯：写完高精度模块，先和Python自带的int对拍几组随机数据，确认结果完全一致再上线。Python的大整数是最可靠的高精度实现，拿它当参照，能省下大量手工对账的时间。高精度看似枯燥，但只要把存储、进位、借位、试商这些核心逻辑吃透，后续遇到任何大数问题都不会慌。