C语言实现超级大数的加法、乘法、阶乘

最新推荐文章于 2024-07-11 10:25:33 发布
最新推荐文章于 2024-07-11 10:25:33 发布
阅读量2.4k 收藏 17
点赞数 3
分类专栏： 算法 数据结构与算法 文章标签： c语言 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42318668/article/details/122167272
版权

C语言实现超级大数的加法、乘法、阶乘

说明

超级大数的范围在 0~1e9223372036854775807，也就是最大是 99999........99999（中间9223372036854775807个9）

实现了：

  • 大数 + 大数 => 大数
  • 大数 x 个位数 => 大数
  • 大数 x 大数 => 大数
  • int阶乘 =>大数

所有参与运算的大数都要大于0，还没有做小于0的处理。

主要实现原理和算法思路

用数组表示大数，每一位表示一个数字。

加法就是将两个大数按位累加，处理进位就用一个额外的变量保存。

乘法 a x b 就是将b的每一位数字和a相乘（每一位都处理和判断进位问题），对应还要将它扩大10的n次方倍，再将所有的相乘的结果相加构成一个新的大数。就是结果。（和小学手算高位数乘法，列竖式，原理一样）

阶乘：不停的调用大数乘法。

缺点

用数组实现的大数，但是数组里面的每一位都用的一个int来表示一个个位数字，空间浪费严重。

时间复杂度可能依然待优化，计算6000的阶乘需要6秒左右。

使用了数组动态扩容的方法来存储大数，没有考虑到链表这种节点式存储结构

还没有实现负数，减法操作，因此只能表示正数

潜在的bug和漏洞

将字符串转成大数的过程中没有处理非数字字符，如果将含有非数字字符的字符串转化成大数，会出现错误。

大数销毁方法的好像还不干净彻底，经过测试发现循环打印1~1000的阶乘，内存占用会持续增长，累计占用达到了8G左右。

代码使用方法

把下面的代码全部复制到你的项目中去，具体的使用方法可以看代码中最下面的main函数里面的用法。以及每个函数的用法可以看具体的注释

源代码

main.c

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

/**
 * 大数类型
 * 最大值理论上可以是
 * 1e9223372036854775807
 * 99999........99999（中间9223372036854775807个9）
 */
struct bigNum {
    int *arr;  // 位数数组
    long long _arrLen;  // 数组位数的当前最大长度
    long long wei;  // 有多少位 初始是1 表示现在这个数是个位数
} typedef BigNum;

/**
 * 获取一个初始化的大数字对象，值为0
 * @return 大数对象，值为零
 */
BigNum getZero() {
    BigNum res;
    res._arrLen = 2;  // 设定一开始的位数
    res.arr = (int *) malloc(sizeof(int) * res._arrLen);
    res.wei = 1;
    res.arr[0] = 0;
    return res;
}

/**
 * 销毁一个大数对象
 * @param bigNum 大数对象地址
 */
void destroyBigNum(BigNum *bigNum) {
    free(bigNum->arr);
}

/**
 * 给大数对象中的数组扩容，扩容策略是
 * 2, 4, 8, 16 每次空间不够时，都扩充成原来的两倍
 * @param bigNum 需要扩容的大数对象地址
 */
void extendBigNum(BigNum *bigNum) {
    bigNum->_arrLen *= 2;
    bigNum->arr = (int *) realloc(bigNum->arr, sizeof(int) * bigNum->_arrLen);
}

// 整形乘方计算
int myPow(int n, int m) {
    if (m == 0) {
        return 1;
    }
    int res = n;
    for (int i = 1; i < m; i++) {
        res *= n;
    }
    return res;
}

/**
 * 判断m是多少位数
 * @param m
 * @return 如果m是 169 则返回 3
 */
int getIntWei(int m) {
    int n = 0;
    do {
        n++;
        m /= 10;
    } while (m > 0);
    return n;
}

/**
 * 将一个 int 数字转化成 BigNum类型
 * @param int 输入的int类型数
 * @return bigNum 大数对象
 */
BigNum intToBigNum(int integer) {
    int n = getIntWei(integer);
    BigNum res = getZero();
    while (res._arrLen < n) {
        extendBigNum(&res);
    }
    for (int i = 1; i <= n; i++) {
        int dig = (integer % (myPow(10, i))) / myPow(10, (i - 1));
        res.arr[i - 1] = dig;
    }
    res.wei = n;
    return res;
}

/**
 * 将数字字符串转化为大数对象
 * @param string 字符串，如 "1234535543"
 * 字符串只能是纯数字，如果出现其他字符会导致程序bug
 * @return 大数对象
 */
BigNum stringToBigNum(char *string) {
    BigNum res = getZero();
    while (res._arrLen < strlen(string)) {
        extendBigNum(&res);
    }
    for (long long i = 0; i < strlen(string); i++) {
        res.arr[strlen(string) - i - 1] = (int) (string[i]) - 48;
    }
    res.wei = (long long) strlen(string);
    return res;
}

/**
 * 将大数打印成一行打印出来
 * @param bigNum 大数对象地址
 */
void printBigNumLn(BigNum *bigNum) {
    for (long long i = bigNum->wei - 1; i >= 0; i--) {
        printf("%d", bigNum->arr[i]);
    }
    printf("\n");
}

/**
 * 打印这个大数具体的信息
 * 包含了直观表示，内部数组存储结构，位数和当前数组长度。
 * @param bigNum 大数对象地址
 */
void printBigNumObj(BigNum *bigNum) {
    for (long long i = bigNum->wei - 1; i >= 0; i--) {
        printf("%d", bigNum->arr[i]);
    }
    printf(" [");
    for (int i = 0; i < bigNum->wei; i++) {
        printf("%d ", bigNum->arr[i]);
    }
    printf("]");
    printf("arrLen:%lld;wei:%lld\n", bigNum->_arrLen, bigNum->wei);
}

/**
 * 将这个大数对象增加它自己，也就是乘以2倍
 * 输入 231 => 462
 * @param bigN 大数对象地址
 * 无返回值，函数调用直接修改大数对象自身的值
 */
void bigNumAddSelf(BigNum *bigN) {
    // 扩容检测
    if (bigN->arr[bigN->wei - 1] >= 5 && bigN->wei == bigN->_arrLen) {
        extendBigNum(bigN);
    }
    int next = 0;  // 下一位进位现象 0 无进位，1有进位
    for (long long i = 0; i < bigN->wei; i++) {
        int res = bigN->arr[i] * 2 + next;
        if (res < 10) {
            bigN->arr[i] = res;
            next = 0;
        } else {
            bigN->arr[i] = res - 10;
            next = 1;
        }
        // 判断最后是不是多出来一位
    }
    if (next == 1) {
        // printf("up wei\n");
        bigN->arr[bigN->wei] = 1;
        bigN->wei++;
    }
}

/**
 * 把b2里面的内容拷贝到b1里面去
 * 深拷贝
 * copy:  b1 <=== b2
 * @param b1 大数对象地址 接收
 * @param b2 大数对象地址 提供复制
 * 无返回值，函数调用直接修改大数对象 b1 自身的值
 */
void bigNumCopy(BigNum *b1, BigNum *b2) {
    if (b1->_arrLen < b2->_arrLen) {
        // 扩容1
        b1->_arrLen = b2->_arrLen;
        b1->arr = (int *) realloc(b1->arr, sizeof(int) * b1->_arrLen);
    }
    // 先将b1内的数据清零
    for (long long i = 0; i < b1->_arrLen; i++) {
        b1->arr[i] = 0;
    }
    // 一位一位复制
    for (long long i = 0; i < b2->wei; i++) {
        b1->arr[i] = b2->arr[i];
    }
    b1->wei = b2->wei;
}

/**
 * 大数比较大小，
 * @param b1 大数对象地址
 * @param b2 大数对象地址
 * @return 如果 b1 > b2 返回 1 ; 如果 b1 < b2 返回 -1；相等返回 0
 */
int bigNumCmp(BigNum *b1, BigNum *b2) {
    if (b1->wei > b2->wei) {
        return 1;
    } else if (b1->wei < b2->wei) {
        return -1;
    } else {
        // 从高位向低位比较
        for (long long i = b1->wei - 1; i >= 0; i--) {
            if (b1->arr[i] > b2->arr[i]) {
                return 1;
            } else if (b1->arr[i] < b2->arr[i]) {
                return -1;
            }
        }
        return 0;
    }
}

/**
 * 大数相加 有返回值版
 * @param b1 大数对象地址
 * @param b2 大数对象地址
 * @return 返回一个新的大数对象
 */
BigNum bigNumPlus(BigNum *b1, BigNum *b2) {
    // 注意左边的参数的值比右边的要大
    if (bigNumCmp(b1, b2) == -1) {
        BigNum *temp = b1;
        b1 = b2;
        b2 = temp;
    }
    BigNum res = getZero();
    if (b1->wei == b1->_arrLen) {
        extendBigNum(b1); // 最高位刚好达到数组了就直接扩容，不判断了
    }
    bigNumCopy(&res, b1);
    // b2 要扩容到和res一样的水平
    if (b2->_arrLen < res._arrLen) {
        b2->_arrLen = res._arrLen;
        b2->arr = (int *) realloc(b2->arr, sizeof(int) * b2->_arrLen);
        // 多扩容出来的数据要清零
        for (long long i = b2->wei; i < b2->_arrLen; i++) {
            b2->arr[i] = 0;
        }
    }
    while (b2->_arrLen <= res._arrLen) {
        extendBigNum(b2);
    }
    int next = 0;  // 下一位进位现象 0 无进位，1有进位
    for (long long i = 0; i < res.wei; i++) {
        int resNum = b2->arr[i] + res.arr[i] + next;
        if (resNum < 10) {
            res.arr[i] = resNum;
            next = 0;
        } else {
            res.arr[i] = resNum - 10;
            next = 1;
        }
    }
    // 判断最后是不是多出来一位
    if (next == 1) {
        res.arr[res.wei] = 1;
        res.wei++;
    }
    return res;
}

/**
 * 大数相加 无返回值版
 * 把b2加到b1上
 * @param b1 大数对象地址
 * @param b2 大数对象地址
 * 无返回值，直接通过地址修改了b1的值。
 */
void bigNumAdd(BigNum *b1, BigNum *b2) {
    if (b1->wei == b1->_arrLen) {
        extendBigNum(b1); // 最高位刚好达到数组了就直接扩容，不判断了
    }
    int flag = bigNumCmp(b1, b2);
    if (flag == -1) {
        // 后边大，前面小
        while (b1->_arrLen < b2->_arrLen) {
            extendBigNum(b1);
        }
        // 前面0化
        for (long long i = b1->wei; i < b1->_arrLen; i++) {
            b1->arr[i] = 0;
        }
    }
    int next = 0;  // 下一位进位现象 0 无进位，1有进位
    for (long long i = 0; i < b2->wei; i++) {
        int resNum = b1->arr[i] + b2->arr[i] + next;
        if (resNum < 10) {
            b1->arr[i] = resNum;
            next = 0;
        } else {
            b1->arr[i] = resNum - 10;
            next = 1;
        }
    }
    if (b2->wei > b1->wei) {
        b1->wei = b2->wei;
    }
    // 判断最后是不是多出来一位
    if (next == 1) {
        b1->arr[b1->wei]++;
        b1->wei++;
    }
}

/**
 * 将一个大数乘以多少倍数，倍数是个位数(<10)
 * @param bgn 大数对象地址
 * @param a 自觉保证是个位数
 * 无返回值，函数调用直接修改 bgn 的值
 */
void bigNumMulDig(BigNum *bgn, int a) {
    // 乘以0要特殊处理
    if (a == 0) {
        bgn->wei = 1;
        bgn->arr[0] = 0;
        return;
    }
    // 如果这个数最高位刚好顶满了数组，那么可能就会有数组溢出的风险，直接扩容
    if (bgn->wei == bgn->_arrLen) {
        extendBigNum(bgn);
    }
    int next = 0;
    for (long long i = 0; i < bgn->wei; i++) {
        int resNum = bgn->arr[i] * a + next;
        if (resNum < 10) {
            bgn->arr[i] = resNum;
            next = 0;
        } else {
            next = resNum / 10;
            bgn->arr[i] = resNum % 10;
        }
    }
    if (next) {
        bgn->arr[bgn->wei] = next;
        bgn->wei++;
    }
}

/**
 * 将一个大数对象的结尾增加n个零
 * @param bgn 大数对象
 * @param a 增加几个0，如果是1就是扩大十倍，如果是2就是扩大100倍，如果是0就是不扩大
 * 例如：
 *  (大数=1124, a=3)  => 大数变成：1124000
 * 无返回值，函数调用直接修改 bgn 的值
 */
void bigNumAppend0(BigNum *bgn, long long a) {
    if (a <= 0) {
        return;
    }
    while (bgn->wei + a > bgn->_arrLen) {
        extendBigNum(bgn);
    }
    for (long long i = bgn->wei - 1; i >= 0; i--) {
        bgn->arr[i + a] = bgn->arr[i];
    }
    for (int i = 0; i < a; i++) {
        bgn->arr[i] = 0;
    }
    bgn->wei += a;
}

/**
 * 大数乘法 b1 * b2
 * @param b1
 * @param b2
 * @return 返回大数乘法后的结果
 */
BigNum bigNumMul(BigNum *b1, BigNum *b2) {
    BigNum res = getZero();
    // 注意左边的参数的值比右边的要大
    if (bigNumCmp(b1, b2) == -1) {
        BigNum *temp = b1;
        b1 = b2;
        b2 = temp;
    }
    for (long long i = 0; i < b2->wei; i++) {
        // 遍历b2的每一位
        int w = b2->arr[i];
        BigNum newBg = getZero();
        bigNumCopy(&newBg, b1);  // 被乘数b1复制一份
        bigNumMulDig(&newBg, w);
        bigNumAppend0(&newBg, i);
        bigNumAdd(&res, &newBg);
    }
    return res;
}

/**
 * 阶乘
 * @param n 数字
 * @return 阶乘的结果
 */
BigNum jie(int n) {
    BigNum res = getZero();
    res.arr[0] = 1;
    for (int i = 1; i <= n; i++) {
        BigNum bigI = intToBigNum(i);
        res = bigNumMul(&res, &bigI);
        destroyBigNum(&bigI);
    }
    return res;
}

int main() {
    // 大数相加
    BigNum b1 = intToBigNum(1);
    printBigNumObj(&b1);
    BigNum b2 = intToBigNum(95599);
    printBigNumObj(&b2);
    BigNum b3 = bigNumPlus(&b1, &b2);
    printBigNumObj(&b3);

    // 大数乘以个位数
    BigNum bg1 = intToBigNum(11665544);
    bigNumMulDig(&bg1, 6);
    printBigNumObj(&bg1);

    // 大数乘以大数
    BigNum bg3 = intToBigNum(166655466);
    BigNum bg4 = intToBigNum(443335544);
    BigNum bg5 = bigNumMul(&bg3, &bg4);
    printBigNumObj(&bg5);

    // 字符串版 大数乘以大数
    BigNum bgn1 = stringToBigNum("8717829120915684686898899879870");
    BigNum bgn2 = stringToBigNum("1555888888564684684684684888888");
    BigNum bgn3 = bigNumMul(&bgn1, &bgn2);
    printBigNumObj(&bgn3);

    // 遍历输出阶乘结果
    // for (int i = 1; i < 1000; i++) {
    //     BigNum result = jie(i);
    //     printf("!%d\n", i);
    //     // printBigNumObj(&result);
    //     printBigNumLn(&result);
    //     destroyBigNum(&result);
    // }

    // 计算超大阶乘
    BigNum result = jie(6000);
    printBigNumLn(&result);
}
Littlefean
关注
专栏目录
大数求乘法逆元c语言,乘法逆元(编程计算)+两道版题
weixin_39539764的博客
05-19 870
前言看到这里的小盆友们千万不要以为这个东西很难,其实就是个1+1->1(1个定义+1个定理->1坨乘法逆元).Let’s begin.web有关乘法逆元定义这个咱们就不要玩笑了,来，直接看定义：乘法:是指将相同的数加起来的快捷方式。(呵呵呵)逆元素：指一个能够取消另外一给定元素运算的元素，在数学里，逆元素广义化了加法中的加法逆元和乘法中的倒数。(???)乘法逆元:群G中任意一个元素a，...
大数乘法C语言实现
qq_41409120的博客
02-21 442
引入 今天在东华oj刷题的时候遇到了大数阶乘，需要用到大数乘法。说来大数乘法以前上算法课的时候学过，不过现在已经忘了…… 重新学了下，虽然原理看懂了，但是因为这里面细节太多，防不胜防（加上我比较菜），程序写出来之后调试了很久才得出正确答案。 原理 大数乘法的原理说白了就是利用了手动乘法的计算过程。我们手工做乘法的时候（假设A * B），从A的最后一位开始依次乘以B的每一位取余写下，有进位的时候记下...
超大数计算器（C语言实现）
05-24
C语言实现，可以实现超大位数的加减乘除
大数相乘算法
weixin_33775572的博客
08-23 369
几年前曾经写过大数相乘，但也忘记怎么写了。今天重新写了一个，中心思想就是把乘法变成加法，用字符串的方式去模拟。 感觉效率很差，算1000！花了2分23秒。有很多地方可以优化，但是目前还没时间去想。 顺便记一下： 1000!= 40238726007709377354370243392300398571937486421071463254379991042993851239862902 ...
如何在 C 语言中处理大整数运算？
最新发布
发现生活，分享智慧，一起成长！
07-11 407
在 C 语言中，标准的数据类型（如 `int`、`long` 等）具有有限的表示范围。当需要处理超出这些范围的大整数时，我们需要采用一些特殊的方法和技术。 # 一、问题分析 处理大整数运算面临的主要问题包括： 1. 表示大整数：标准数据类型无法直接存储大整数，需要选择合适的数据结构来表示。 2. 运算实现：加法、减法、乘法、除法等基本运算需要自定义函数来实现。 3. 效率和内存管理：大整数运算可能涉及大量的计算和内存使用，需要考虑效率和合理的内存分配。
关于大数（C语言）
LANGJ1的博客
12-03 2874
大数，即数字位数超乎想象（至少超乎long long想象）位数的数。因其位数过大，在c语言中不能对其进行直接运算；若想实现运算，则需要一些奇淫小技巧。 大数相加 两数相加的手算操作： 将两数右对齐，由右至左对位相加，结果上再加上一位的进位（如果有的话）；保留该结果个位为这一位，再将多出的位数（也是如果有的话）进给下一位直至两数均消耗完。 懂的都懂，不懂的我也没有办法 下面放代码 #include <stdio.h> int main() { char a[500], b[500];
巨大数（C语言）
quIDhaonan的博客
08-18 4048
何为巨大数呢？顾名思义，巨大数就是数值特别大的数字，大到C语言已经无法识别，例如几千万亿的加减乘除，C语言的int, 与long int显然已经无法表示，因为他们都是四字节的补码，可以表示的整型数字范围为-2,147,483,648 ~ 2,147,483,647, 即-2^32 ~ 2^32-1。 那么该如何解决这个问题呢？ 首先，根据int的特性我们可以使用万进制，类似于十进制，只不过万进制是4位一组，十进制是一位一组。说到这可能就会有人疑惑了，为啥是万进制，不是十万进制，或者千进制呢，偏偏选一个万进制
C语言大数运算——乘法
qq_44248026的博客
01-31 2129
还是大数运算，这次是乘法的。具体都写在代码里面了，就不多说。 /****************************************************************************************/ /* 大数运算篇——乘法 */ /* 56 分析：两个数相乘，最毒不...
算10000以内数阶乘的C语言程序.rar_C语言_阶乘
09-22
在"fac_bignum.c"中，可能定义了一个结构体来存储大数，并实现了加法、乘法等操作。 代码可能会使用一个循环来逐位计算阶乘，每次迭代将当前数乘以前面所有数的累积结果。为了处理大数，每次乘法后可能需要进行进位...
大数阶乘计算(纯c语言).rar
06-12
对于大数，这个过程涉及到多次加法和乘法操作，都需要用到大数的运算。 - 在C语言中，这通常意味着需要编写自定义的加法和乘法函数，以处理多位数的运算。 3. **乘法算法**： - Karatsuba算法和Toom-Cook算法是...
c语言大数阶乘和计算阶乘末尾的0的个数
我自倾怀，君且随意
06-06 2850
一、大数阶乘的数据保存 大数进行阶乘，将数据保存在数组中。这样遍历数组，就可以打印出阶乘的结果。 核心计算就是：将阶乘的乘法转化为加法和进位 比如：计算6！= 2*3*4*5*6  设为i 初始result[1]=1,result.length=1,carry默认是0 i = 2 -------->result[1]=(i*result[1])%10=2,carry=0,没产生进
大数运算-RSA-c语言大数运算库
03-04
大数运算 RSA c语言大数运算库 英文PDf 中文PDF 源码
关于c语言百位大数
11-25
学生成绩管理系统V1.0学生成绩管理系统V1.0学生成绩管理系统V1.0学生成绩管理系统V1.0
大数相乘的C语言实现程序
09-04
实现了两个大数相乘的小程序，数组大小可自行指定，欢迎大家进行验证
C--超大数的四则运算
qq_41030253的博客
08-11 382
写在前面 起因是一道题目，说来惭愧，我记的离散数学课上有教过这个。 思路 加法 从低位到高位，逐位想加，产生进位则高位加1 减法 从低位到高位，逐位想减，产生借位则高位减1 乘法 从低位到高位，乘数逐位乘以被乘数，保存在第三个数组中，判断数组每个元素是否大于10，若大于10，高位加（元素/10），元素 %= 10 除法 用辗转相除法，从高位到低位，被除数 除以 除数 得到商及余数，下一位被除数 = 被除数 + 余数 * 10 代码 #include <stdio.h> #include &
巨大数乘法(C语言)
quIDhaonan的博客
08-23 175
上一篇博客我们实现了巨大数的加减法，现在我来填一下我上个博客结尾留下的坑——巨大数的乘法。 相较于加减法乘法的实现更加容易实现，我们可以类比十进制下的乘法来进行手工过程的实现。 既然十进制的乘法是如此那么在万进制下的乘法也应是如此的，但是如何解决每次计算结果的存储问题呢，这个问题在我编程的时候困扰我了好久。 其实很简单，就是我们把每一轮（或者说每一次）的计算结果按万进制直接存入我们的结果巨大数的数组中就好了。 对了，最终结果巨大数的位数应该是两个相乘巨大数位数之和(在万进制下)。 下来我们看一下核心代码：
c语言巨大数,【数据结构与算法】“巨大数！！！” 的计算
weixin_35075655的博客
05-18 931
巨大数是指一个非常庞大的数，这个数已超过了c语言类型的表示范围，比如：234531231328473234312445646332523。巨大数的计算是指从键盘输入任意两个巨大数，实现两个巨大数之间的加、减、乘运算。分析：上述问题，单纯的用c语言中的基本类型，是很难表示和计算的。由此，先引入一个新的表示方法——万进制。二进制我们都知道是逢二进一，那么万进制与之类似，逢万进一。之所以采用万进制，是想...
利用C语言实现大数加减法
热门推荐
Goku_Yu的博客
08-24 2万+
  大数加法： #include &lt;stdio.h&gt; #include &lt;string.h&gt; #define M 100 //定义了数量M是100作为数组初始化的数量 int main() { int i, j, len_s1, len_s2; // len_s1是字符数组s1的长度， len_s2是字符数组s2的长度， char s1[M], s2[M...
大数的加减法（C语言版）
m0_51690407的博客
12-09 4110
大数：首先大数就是超出比 long long int 范围的数值。那么超出范围后应该怎样计算呢。下面就介绍大数的加减法 大数加法 对于初学者来说代码可能会有点长，但是原理很简单的。 AC： #include <stdio.h> #include <stdlib.h> #include <string.h> char s1[1001],s2[1001];//首先定义两个字符数组来输入大数。 int a[1001]= {0},b[1001]= {0},c[5000]=
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值