当前位置：首页 > news >正文

【算法详解】：编程中的“无限”可能，驾驭超大数的艺术—高精度算法

news 2025/9/15 5:51:11

在这里插入图片描述

🫧 励志不掉头发的内向程序员：个人主页
✨️ 个人专栏: 《C++语言》《Linux学习》

🌅偶尔悲伤，偶尔被幸福所完善

👓️博主简介:

在这里插入图片描述

文章目录

前言
一、算法详解
二、算法原理剖析
- 2.1、加法
- 2.2、减法
- 2.3、乘法
- 2.4、除法
三、代码源码
- 3.1、加法
- 3.2、减法
- 3.3、乘法
- 3.4、除法
总结

前言

在我们科研中，可能会遇到各种计算，就比如1 * 10^100 + 3.21414252 * 10^21 等等，但是我们编程语言，像 C++ 的内置类型最大就只能支持 2^64，如果碰到这种情况我们该怎么办呢，难道就只能干瞪眼吗，答案并非如此，这就得用到我们的一个算法啦，那就是高精度，我们一起来学习学习。

在这里插入图片描述

一、算法详解

当一个数据的值非常大，各种类型都存不下的时候，此时就要用高精度算法来计算加减乘除

高进的的原理：

先用字符串读入这个数，然后用数组逆序存储该数的每一位
利用数组，模拟加减乘除运算过程

我们使用字符串来存储一个1 后面有 1024 个 0 的数字也只要开辟 1024 字节也就是 1kb 的空间而已，但是这个数字就已经非常大了。高精度算法本质还是模拟算法，用代码模拟小学列竖式计算加减乘除的过程。

注意：
我们刚开始之所以用字符串而非数组存储，那是因为我们得把每个数字都分开来存储后进行加减，用数字存还得把每个数字拆分开来，十分麻烦。

二、算法原理剖析

2.1、加法

我们想要实现高精度加法，其实还是比较简单的，只要模拟我们小学时的流程即可。

在这里插入图片描述
我们来看这个竖式，我们加法的原理就是从末项开始加起，加到首项，如果满十就进一，这就是加法的全部流程
首先第一步就是创建两个字符串，然后把要想加的两个数的字符读入这两个字符串中。

string x, y; cin >> x >> y;

此时我们可以去创建 3 个数组，这 3 个数组的意义就是分别用来保存第一个字符串数的每一个数字，第二个是保存第二个字符串数的每一个数字，第三个则是用来把这两个数相加的结果保存起来的。这么做的原因是因为我们字符串相加非常不方便，所以就决定这样做。同时我们可以顺便在全局域中创建 3 个变量来保存这几个数组的大小。

// 全局域
const int N = 1e6 + 10;
int a[N], b[N], c[N];
int la, lb, lc;

此时我们得把字符串的数字保存到数组中，同时，由于我们两个数相加是从末项往首项相加的，所以我们保存时得反过来保存，字符串前面的字符得保存到我们数组后面，后面的字符得保存到前面。

la = x.size(); lb = y.size();
for (int i = 0; i < la; i++) a[la - 1 - i] = x[i] - '0';
for (int i = 0; i < lb; i++) b[lb - 1 - i] = y[i] - '0';

此时我们不要忘记了，我们的 c 数组是保存最后的结果的，所以我们也得用 lc 去记录我们的数加起来有多少位。而我们的两个数相加我们记录最大的数的位数即可。

 lc = max(la, lb);

此时我们就可以对这两个数组从前往后进行加操作了。
在这里插入图片描述
加操作：

对应位累加
处理进位
处理余数
对应位相加非常简单，那就直接是两个数组下标直接相加即可。

c[i] += a[i] + b[i];

而我们的处理进位主要运用的是我们的除法，因为我们的 C++ 是向下取整的，所以如果我们用一个数 / 10，此时我们得到的数刚好就是我们要进的位。

c[i + 1] += c[i] / 10;

而余数要用到的就是我们的 %，我们拿数 % 10 得到的就是我们那个下标的余数了。

c[i] %= 10;

此时我们把这几个合并起来。

for (int i = 0; i < lc; i++)
{c[i] += a[i] + b[i]; // 对应位相加，再加上进位c[i + 1] += c[i] / 10; // 处理进位c[i] %= 10; // 处理余数
}

当然，我们数组的最后一位也有可能会进一，

在这里插入图片描述
此时我们上面的循环到最后一位时刚好就会进位，所以我们只需要判断我们lc位置是不是 0 ，如果不是 0 就证明进位了，我们改变 lc，让它 + 1 即可。

if(c[lc]) lc++;

2.2、减法

模拟小学列竖式计算两数相减的过程即可。

我们减法和加法的流程其实大致上是相同的。
在这里插入图片描述
但是不同的是，我们两式相减可能会出现负数。

此时我们可以在算数之前先比较它们的大小，如果减数比被减数大，那我们可以把它们调换，然后输出时记得多输出一个 - 即可。

由于我们的数字在 ASCII 中也是从小到大按照从 0 到 9 排序的，所以我们在判断两个字符一样长的情况下只需要在字符串期间从前到后每个字符进行比较即可。当然，我们 string 重载的比较方式就是这样的。

bool cmp(string& x, string& y)
{// 先⽐较⻓度if (x.size() != y.size()) return x.size() < y.size();// 再按照 字典序 的⽅式⽐较return x < y;
}string x, y; cin >> x >> y;
// ⽐⼤⼩
if (cmp(x, y))
{swap(x, y);cout << '-';
}

我们想要进入减法前期的准备和加法也是一样的，先创造 3 个数组，以及用变量保存它们有多少位数字。

// 全局变量
const int N = 1e6 + 10;
int a[N], b[N], c[N];
int la, lb, lc;// main
// 1. 拆分每⼀位，然后逆序放在数组中
la = x.size(); lb = y.size(); lc = max(la, lb);
for (int i = 0; i < la; i++) a[la - i - 1] = x[i] - '0';
for (int i = 0; i < lb; i++) b[lb - i - 1] = y[i] - '0';

此时我们就可以来模拟我们的竖式计算过程啦。
减操作：

对应位求差
处理借位
对应位球差很简单，直接相减即可。

c[i] += a[i] - b[i];

如果我们相减完发现数组中是负数，那我们向前借位即可。

if(c[i] < 0)
{
c[i + 1] -= 1; // 借位
c[i] += 10;
}

由于我们已经交换了减数和被减数，所以我们被减数永远比减数大，可以放心这样操作。
减完之后由于我们可能会出现前导 0，所以我们得处理一下这种情况。
在这里插入图片描述

我们判断剪完后我们 lc 是否为 0，如果为 0 就 lc–，当然有可能最后的结果就是 0，所以我们增加一个 lc > 1 的条件。

// 处理前导零
while(lc > 1 && c[lc - 1] == 0) lc--;

注意：
这里 lc - 1 是因为我们数组是从 0 开始的，所以到末尾应该是 lc - 1 而非 lc。

2.3、乘法

我们乘法也可以使用小学时那种列竖式的办法，但是那种办法比较麻烦，我们这里可以使用一种新的办法。

我们计算乘法时，可以先无进位相乘，然后再相加。

还是列竖式，但是每一位相乘的时候不考虑进位，直接把乘的结果放在对应位上；
等到所有对应位置乘完并且累加完之后，统⼀处理进位。

在这里插入图片描述
我们可以利用这种方法比较容易的完成我们的任务。
首先和前面的加减的方法一样，用字符串读入数据，将字符串的每一位拆分，逆序放在数组中。

// 全局域
const int N = 1e6 + 10;
int a[N], b[N], c[N];
int la, lb, lc;

// main
string x, y; cin >> x >> y;
// 1. 拆分每⼀位，逆序放在数组中
la = x.size(); lb = y.size(); lc = la + lb;
for(int i = 0; i < la; i++) a[la - 1 - i] = x[i] - '0';
for(int i = 0; i < lb; i++) b[lb - 1 - i] = y[i] - '0';

此时我们的 lc 变成了 la + lb 相加，我们验证一下即可，就比如我们 3 位数 x 2 位数，最小的两个数相乘就是 100 x 10 = 1000，4 位数。而最大的两位数相乘 999 x 99 = 98901 是 5 位数，所以我们后期还得针对 4 位数进行处理，也就是处理前导 0（如果 lc 比 5 大就没有必要，比 5 小就会有一部分读不出来，所以 lc = la + lb 是最优解）。

此时我们按照上面的无进位相乘操作即可。
相乘操作：

对应位求乘积
乘完之后处理进位
处理余数

由于我们相乘是乘数的每一位都要和被乘数相乘，所以我们这里得用到两个 for 循环。

for(int i = 0; i < la; i++)
{for(int j = 0; j < lb; j++){}
}

此时，由于我们在对应位置乘完之后还得相加。
在这里插入图片描述
此时我们记录下这些位置的下标就会发现。

我们处在同一列上的数字 i + j 的值是相同的，而且刚好第一列的数字下标为 0，第二列的数字下标为 1 依次类推，所以我们只需要让我们的 c[i + j] = a[ i ] * b[ j ] 即可。

c[i + j] += a[i] * b[j];

当我们相乘完并且相加完时，我们便可处理进位了。和加法那里是一样的。

// 处理进位
for(int i = 0; i < lc; i++)
{c[i + 1] += c[i] / 10;c[i] %= 10;
}

当然，我们也得处理前导 0 的问题。
在这里插入图片描述

while(lc > 1 && c[lc - 1] == 0) lc--;

2.4、除法

模拟小学列竖式计算两数相除的过程（注意，我们这里是高精度 ÷ 低精度）。

定义一个指针 i 从高位遍历被除数，⼀个变量 t 标记当前被除的数，记除数是 b ；
在这里插入图片描述
由于是高精度除以低精度，所以我们创建两个数组即可。

// 全局域
const int N = 1e6 + 10;
typedef long long LL;
int a[N], b, c[N];
int la, lc;

前面也是一样的处理办法，我们除法其实是从前往后除的，但是如果不反过来，那我们处理前导 0 时就会比较麻烦，还浪费内存，所以就反过来存储就好了。
在这里插入图片描述

string x; cin >> x >> b;
la = x.size();
for(int i = 0; i < la; i++) a[la - 1 - i] = x[i] - '0';

模拟除法：

更新⼀个当前被除的数 t = t × 10 + a[ i ]
t/b 表示这⼀位的商， t % b 表示这一位余数
用 t 记录这⼀次的余数，遍历到下⼀位的时候重复上面的过程

被除数遍历完毕之后， t 里面存的就是余数，但是商可能存在前导 0 ，注意清空。

LL t = 0; // 标记每次除完之后的余数
for(int i = la - 1; i >= 0; i--)
{// 计算当前的被除数t = t * 10 + a[i];c[i] = t / b;t %= b;
}
// 处理前导 0
while(lc > 1 && c[lc - 1] == 0) lc--;

三、代码源码

3.1、加法

const int N = 1e6 + 10;
int a[N], b[N], c[N];
int la, lb, lc;
// ⾼精度加法的模版 - c = a + b;
void add(int c[], int a[], int b[])
{for (int i = 0; i < lc; i++){c[i] += a[i] + b[i]; // 对应位相加，再加上进位c[i + 1] += c[i] / 10; // 处理进位c[i] %= 10; // 处理余数}if (c[lc]) lc++;
}int main()
{string x, y; cin >> x >> y;// 1. 拆分每⼀位，逆序放在数组中la = x.size(); lb = y.size(); lc = max(la, lb);for (int i = 0; i < la; i++) a[la - 1 - i] = x[i] - '0';for (int i = 0; i < lb; i++) b[lb - 1 - i] = y[i] - '0';// 2. 模拟加法的过程add(c, a, b); // c = a + b// 输出结果for (int i = lc - 1; i >= 0; i--) cout << c[i];return 0;
}

3.2、减法

const int N = 1e6 + 10;
int a[N], b[N], c[N];
int la, lb, lc;
// ⽐⼤⼩
bool cmp(string& x, string& y)
{// 先⽐较⻓度if (x.size() != y.size()) return x.size() < y.size();// 再按照 字典序 的⽅式⽐较return x < y;
}
// ⾼精度减法的模板 - c = a - b
void sub(int c[], int a[], int b[])
{for (int i = 0; i < lc; i++){c[i] += a[i] - b[i]; // 对应位相减，然后处理借位if (c[i] < 0){c[i + 1] -= 1; // 借位c[i] += 10;}}// 处理前导零while (lc > 1 && c[lc - 1] == 0) lc--;
}
int main()
{string x, y; cin >> x >> y;// ⽐⼤⼩if (cmp(x, y)){swap(x, y);cout << '-';}// 1. 拆分每⼀位，然后逆序放在数组中la = x.size(); lb = y.size(); lc = max(la, lb);for (int i = 0; i < la; i++) a[la - i - 1] = x[i] - '0';for (int i = 0; i < lb; i++) b[lb - i - 1] = y[i] - '0';// 2. 模拟减法的过程sub(c, a, b); // c = a - b// 输出结果for (int i = lc - 1; i >= 0; i--) cout << c[i];return 0;
}

3.3、乘法

const int N = 1e6 + 10;
int a[N], b[N], c[N];
int la, lb, lc;
// ⾼精度乘法的模版 - c = a * b
void mul(int c[], int a[], int b[])
{// ⽆进位相乘,然后相加for (int i = 0; i < la; i++){for (int j = 0; j < lb; j++){c[i + j] += a[i] * b[j];}}// 处理进位for (int i = 0; i < lc; i++){c[i + 1] += c[i] / 10;c[i] %= 10;}// 处理前导零while (lc > 1 && c[lc - 1] == 0) lc--;
}
int main()
{string x, y; cin >> x >> y;// 1. 拆分每⼀位，逆序放在数组中la = x.size(); lb = y.size(); lc = la + lb;for (int i = 0; i < la; i++) a[la - 1 - i] = x[i] - '0';for (int i = 0; i < lb; i++) b[lb - 1 - i] = y[i] - '0';// 2. 模拟乘法的过程mul(c, a, b); // c = a * b// 输出结果for (int i = lc - 1; i >= 0; i--) cout << c[i];return 0;
}

3.4、除法

const int N = 1e6 + 10;
typedef long long LL;
int a[N], b, c[N];
int la, lc;
// ⾼精度除法的模板 - c = a / b （⾼精度 / 低精度）
void sub(int c[], int a[], int b)
{LL t = 0; // 标记每次除完之后的余数for (int i = la - 1; i >= 0; i--){// 计算当前的被除数t = t * 10 + a[i];c[i] = t / b;t %= b;}// 处理前导 0while (lc > 1 && c[lc - 1] == 0) lc--;
}
int main()
{string x; cin >> x >> b;la = x.size();for (int i = 0; i < la; i++) a[la - 1 - i] = x[i] - '0';// 模拟除法的过程lc = la;sub(c, a, b); // c = a / bfor (int i = lc - 1; i >= 0; i--) cout << c[i];return 0;
}