大数之四则运算

最新推荐文章于 2022-03-11 11:59:04 发布
最新推荐文章于 2022-03-11 11:59:04 发布
阅读量815 收藏 8
点赞数 2
分类专栏： 后端开发 文章标签： 大数 四则运算
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qican_7/article/details/93645593
版权

目录

1. 大数之四则运算总结

1.1 加法

1.2 减法

1.3 乘法

1.4 除法

2. 加法

3. 减法

4. 乘法

5. 除法

6. 参考文献

1. 大数之四则运算总结

1.1 加法

从后往前算（即由低位向高位运算），计算的结果依次添加到结果中去，最后将结果字符串反转。

1.2 减法

原理同加法，将进位改为借位

1.3 乘法

第一个数据的第i位与第二个数据的第j位相乘存放在结果的第[i+j]个元素中，因为结果的每一位不是顺序得出，所以不方便用字符串存储，转而用数组存储。另一方面，第一步不考虑进位的问题，先将相乘的结果保存在数组中，然后对数组中的元素需要进位的按进位规则处理。

1.4 除法

利用了前面的大数相减的部分，主要思路为：以999除以9为例，两数相差两位，想让9*100=900,999可以减去9个100，然后9*10=90，余下的99可以减10个90，然后余下的9可以减去1个9，那么从前往后依次拼接每阶段得到的结果，最终得到111。

2. 加法

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

using namespace std;

string add(string& data1, string &data2){
    int len1 = data1.length();
    int len2 = data2.length();
    int len = min(len1,len2);
    string res = "";
    int carry = 0;  //进位
    int cur = 0;   //当前位
    string tmp;

    size_t i = 0;
    for (; i < len; i++)
    {
        cur = data1[len1-i-1] + data2[len2-i-1] - 2*'0' + carry;  //计算当前位 从后往前算

        carry = cur/10;  //计算进位

        cur = cur%10;   //计算当前位
        
        stringstream ss;
        ss<<cur;

        tmp = ss.str();

        res += tmp;   //添加到结果中

        // cout<<res<<endl;
    }

    if (len1 < len2)
    {
        data1 = data2;  //直接把较长的数给data1
    }

    for (; i < data1.length(); i++)
    {
        cur = data1[data1.length() - i - 1] - '0' + carry;  //将较长的数的剩下部分添加到结果中

        carry = cur/10;

        cur = cur % 10;

        stringstream ss;
        ss<<cur;

        tmp = ss.str();

        res += tmp;
    }

    if (carry > 0)
    {
        res += carry;
    }

    // cout<<"res:"<<res<<endl;

    reverse(res.begin(), res.end());  //将结果反转

    // cout<<"res:"<<res<<endl;

    return res;

}

int main()
{
    string data1 = "123456";
    string data2 = "1234567";

    string res = add(data1,data2);

    cout<<"res:"<<res<<endl;

    return 0;
}

3. 减法

基本思路和加法类似，进位变为借位，在运算之前需要判断正负，将大的数放在被减数上，因此，在需要的时候将被减数和减数调换一下位置。

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

using namespace std;

string sub(string &data1, string &data2)
{
    int len1 = data1.length();
    int len2 = data2.length();
    bool isNeg = false; //判断是否为负
    int cur = 0;  // 当前位
    int carry = 0; //借位
    string res = "";

    if (len1 < len2)  //很重要，在做运算前，将大的数作为被减数，这样可以避免很多问题
    {
        isNeg = true;
        string tmp = data1;  //被减数小于减数，则调换位置，数据和长度都要调换
        data1 = data2;
        data2 = tmp;
        len1 = data1.length();
        len2 = data2.length();
    }else if (len1 == len2)   //当两个字符串的长度相等时，怎么判断哪个字符串比较大，这个逻辑比较有意思
    {
        for (size_t i = 0; i < len1; i++)
        {
            if (data1[i] < data2[i])
            {
                isNeg = true;
                string tmp = data1;
                data1 = data2;
                data2 = tmp;
                break;
            }else if (data1[i] > data2[i])
            {
                isNeg = false;
            }
            
            
        }
        
    }

    int len = min(len1, len2);

    size_t i = 0;

    for (; i < len; i++)
    {
        cur = data1[len1 - i - 1] - data2[len2 - i - 1] - carry;  //字符相减与整数相减一样，不用减'0'

        if (cur < 0)
        {
            cur = cur + 10;
            carry = 1;
        }else
        {
            carry = 0;
        }

        stringstream ss;

        ss<<cur;
        string tmp = ss.str();
        
        res += tmp;

        
    }

    for (; i < len1; i++) //将最长的字符串的剩余部分添加到结果当中
    {
        cur = data1[len1 - i - 1] - '0' - carry; //减去借位, 这里必须减‘0’，容易忽略

        if (cur < 0)
        {
            cur = cur + 10;
            carry = 1;
        }else
        {
            carry = 0;
        }

        stringstream ss;

        ss<<cur;
        string tmp = ss.str();
        
        res += tmp;
    }

    int index = len1 - 1;

    while (res[index] == '0')  //从后面开始的“0”全部去掉，找到不为0的第一个下标
    {
        index --;
    }

    res = res.substr(0,index+1); 

    if (res.length() == 0)  //特殊情况，为零则返回“0”，避免-0的情况出现
    {
        return "0";
    }
    

    if (isNeg) //负数则加负号
    {
        res += "-";
    }

    reverse(res.begin(), res.end());  //与加法一样，反转

    return res;
    
    
}

int main()
{
    string data1 = "1234567";
    string data2 = "1234567";

    string res = sub(data1,data2);

    cout<<"res:"<<res<<endl;

    return 0;
}

4. 乘法

第一个数据的第i位与第二个数据的第j位相乘存放在结果的第[i+j]个元素中，因为结果的每一位不是顺序得出，所以不方便用字符串存储，转而用数组存储。另一方面，第一步不考虑进位的问题，先将相乘的结果保存在数组中，然后对数组中的元素需要进位的按进位规则处理。

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

using namespace std;

string multi(string &data1, string &data2)
{
    int len1 = data1.length();
    int len2 = data2.length();
    int cur = 0;  // 当前位
    int carry = 0; //借位
    string result = "";
    
    int res[5000] = {0};  //借用数组暂时存储，因为第一步不考虑进位，所以每一次相乘的结果可能大于0

    for (size_t i = 0; i < len1; i++)
    {
        for (size_t j = 0; j < len2; j++)
        {
            res[i+j] += (data1[len1 - i - 1] - '0') * (data2[len2 - j - 1] - '0'); //第一个数据的第i个元素和第二个数据的第j和元素相乘存到结果的第【i+j】个元素中
                                                                                   //暂时不考虑进位
        }
        
    }

    for (size_t i = 0; i < len1+len2+1; i++)  //依次往后进位，len1长度和len2长度的数据相乘，结果的长度不超过len1+len2
    {
        cur = (res[i] + carry) % 10;
        carry = (res[i] + carry) / 10;
        res[i] = cur;
    }
    

    size_t index = len1+len2;
    for (; index >=0; index--)
    {
        if (res[index] != 0)
        {
            break;
        }
        
    }

    for (int i = index; i >= 0; i--)
    {
        stringstream ss;
        ss<<res[i];
        string tmp = ss.str();
        result += tmp;
    }
    
    
    return result;

    
    
}

int main()
{
    string data1 = "999";
    string data2 = "99";

    string res = multi(data1,data2);

    cout<<"res:"<<res<<endl;

    return 0;
}

5. 除法

利用了前面的大数相减的部分，主要思路为：以999除以9为例，两数相差两位，想让9*100=900,999可以减去9个100，然后9*10=90，余下的99可以减10个90，然后余下的9可以减去1个9，那么从前往后依次拼接每阶段得到的结果，最终得到111。

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

using namespace std;

bool sub(string &data1, string &data2)
{
    int len1 = data1.length();
    int len2 = data2.length();
    bool isNeg = false; //判断是否为负
    int cur = 0;  // 当前位
    int carry = 0; //借位
    string res = "";

    if (len1 < len2)  //很重要，在做运算前，将大的数作为被减数，这样可以避免很多问题
    {
        return false;
    }else if (len1 == len2)   //当两个字符串的长度相等时，怎么判断哪个字符串比较大，这个逻辑比较有意思
    {
        for (size_t i = 0; i < len1; i++)
        {
            if (data1[i] < data2[i])
            {
               return false;
            }else if (data1[i] > data2[i])
            {
                isNeg = false;
            }
            
            
        }
        
    }

    int len = min(len1, len2);

    size_t i = 0;

    for (; i < len; i++)
    {
        cur = data1[len1 - i - 1] - data2[len2 - i - 1] - carry;  //字符相减与整数相减一样，不用减'0'

        if (cur < 0)
        {
            cur = cur + 10;
            carry = 1;
        }else
        {
            carry = 0;
        }

        stringstream ss;

        ss<<cur;
        string tmp = ss.str();
        
        res += tmp;

        
    }

    for (; i < len1; i++) //将最长的字符串的剩余部分添加到结果当中
    {
        cur = data1[len1 - i - 1] - '0' - carry; //减去借位, 这里必须减‘0’，容易忽略

        if (cur < 0)
        {
            cur = cur + 10;
            carry = 1;
        }else
        {
            carry = 0;
        }

        stringstream ss;

        ss<<cur;
        string tmp = ss.str();
        
        res += tmp;
    }

    int index = len1 - 1;

    while (res[index] == '0')  //从后面开始的“0”全部去掉，找到不为0的第一个下标
    {
        index --;
    }

    res = res.substr(0,index+1); 

    if (res.length() == 0)  //特殊情况，为零则返回“0”，避免-0的情况出现
    {
        data1 = res;
        return true;
    }
    

    if (isNeg) //负数则加负号
    {
        res += "-";
    }

    reverse(res.begin(), res.end());  //与加法一样，反转

    data1 = res;

    return !isNeg;
    
    
}

string div(string &data1, string &data2)
{
    int len1 = data1.length();
    int len2 = data2.length();
    int cur = 0;  // 当前位
    int carry = 0; //借位
    string result = "";
    

    if (len1 < len2)  //如果被除数小于除数则直接返回“0”
    {
        return "0";
    }else if (len1 == len2)   
    {
        for (size_t i = 0; i < len1; i++)
        {
            if (data1[i] < data2[i])
            {
                return "0";
            }else if (data1[i] > data2[i])
            {
                break;
            }
            
            
        }
        
    }

    int count = len1 - len2;  //两个数相差几位
    int res[100] = {0};
    for (int i = count; i >=0; i--)
    {
        string data2_copy = data2;
        for (size_t j = 0; j < i; j++)
        {
            data2_copy += "0";  //后面补0，如果补两个0则为100倍
        }
        while (sub(data1,data2_copy))
        {
            res[count - i] ++;  //能减多少个，从能减的最大数开始减起，直到不能减
        }

        stringstream ss;
        ss<< res[count - i];
        string tmp = ss.str();
        result += tmp;    //依次将能减的数拼接，利用前面写的大数相减
        
        
    }
    
    
    return result;

    
    
}

int main()
{
    string data1 = "999";
    string data2 = "99999";

    string res = div(data1,data2);

    cout<<"res:"<<res<<endl;

    return 0;
}

6. 参考文献

1. https://www.cnblogs.com/wuqianling/p/5387099.html （大数的四则运算（加法、减法、乘法、除法））

qican_7
关注
  • 2
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
大数四则运算的C++实现
We_are_family678的博客
04-04 426
大数四则运算的C++实现[摘要] 大数运算不仅仅运用在密码学中，还运用在一些物理学研究、生物学，化学等科目中。大数运算，意味着参加的值和计算结果通常是以上百位数，上千位数以及更大长度之间的整数运算。例如大家所熟知圆周率π的值，在一般的数值计算中用到圆周率的不须要多大的精度，但在计算一些星球或是星系上的体积面积时便显的误差很大了，这就要求π值计算的精度达到几百万位甚至更高，才能缩小误差。人工计算是远...
大数四则运算以及比较
05-30
在给定的"大数四则运算以及比较"主题中，我们将探讨如何实现大数运算，以及如何设计一个能够处理20亿位数字的计算类。 首先，Int64类型的上限是2^64 - 1，对于超过这个范围的数值，我们需要寻找替代方案。在.NET...
大数的四则运算（附代码）
10-21
详细介绍了关于大数的高精度运算，，加法，减法，乘法，除法都有。
java 大数四则运算_java大数四则运算
weixin_39956451的博客
03-07 128
各种基本操作1 import java.math.BigInteger;2 import java.util.*;3 public class Main{4 public static void main(String[] args)5 {6 Scanner input = new Scanner(System.in);7 BigInteger ...
java 大数四则运算_JAVA大数四则运算
weixin_42110070的博客
02-13 137
import java.io.*;import java.util.*;import java.text.*;import java.math.*;public class Main{public static void main(String []args){Scanner cin = new Scanner(new BufferedInputStream(System.in));while(c...
c语言 大数四则运算,C语言-大整数四则运算
weixin_34863212的博客
05-17 907
#include#include#includetypedef struct bigint{char *num; //指向长整数数组(序号0中保存着最高位)char minus; //符号(1表示正数，-1表示负数)int digit; //保存该数的位数(实际位数)}BIGINT, *pBIGINT;voi...
大数的四则运算
Simple的博客
10-27 618
参考：加减乘除 手动模拟小学生列竖式   一、大数加法（都是正数时） 用两个数组分别逆序存储输入的数，每个位都分别相加，判断是否进位 代码： #include&lt;stdio.h&gt;//大数加法 #include&lt;string.h&gt; #include&lt;math.h&gt; #include&lt;algorithm&gt; using namespace ...
C语言大数四则运算
weixin_58675788的博客
03-11 1224
C语言入门，大数四则运算
算法零基础——大数四则运算
m0_61567378的博客
11-30 849
目录 字符串相加 字符串相乘 二进制求和 千位分隔数 我们知道无论任何类型都有数字的最大范围，所以我们如果想要对于任何两个数都能够进行 四则运算，那么我们就可以运用一个字符串进行运算 字符串相加 字符串相加 给定两个字符串形式的非负整数num1 和num2，计算它们的和并同样以字符串形式返回。 你不能使用任何內建的用于处理大整数的库（比如 BigInteger），也不能直接将输入的字符串转换为整数形式。 示例 1： 输入：num1 = "11", num2 = "123" ...
大数 高精度 四则运算
Raymond_YP的博客
02-13 547
大数的四则运算 高精度计算，是指参与运算的数大大超出了标准数据类型所能表示的范围，例如两个1000位数相乘，这类题目在算法竞赛中出现得很频繁。在c或者c++中，最大数据类型只有64位，如果需要处理更大的数，只能用数组模拟，把大数的每一位存储在数组中，然后按位处理进位、借位。 在网上搜索了一番资料，发现写的都过于繁琐、不易理解，本人写了大数的四则运算（除法暂时没写，明天更新），代码如下。 首先定义一...
大数四则运算——双链表法
07-18
### 大数四则运算——双链表法 在计算机科学与编程领域中，处理大数运算是一项重要的技能。特别是当数字超出标准整型或浮点型数据类型的范围时，传统的方法将不再适用。本文将深入探讨一种特殊的大数运算实现方法...
c++ 大数四则运算
04-06
为了实现大数四则运算，通常需要自定义数据结构和算法。下面将详细讨论如何在C++中进行大数的加减乘除操作。 首先，我们需要创建一个类来存储大数。这个类通常会用数组或链表来存储每一位数字，因为这种数据结构...
大数小数四则运算链表实现
07-05
在IT领域，大数和小数的四则运算通常涉及到高级数学和计算机科学中的算法设计。本主题聚焦于使用链表实现大数和小数的加法、减法、乘法、除法以及幂运算。链表作为一种数据结构，特别适合处理动态变化且长度不固定的...
c语言单链表实现大数的四则运算
watering6的博客
07-17 1370
它运行不了 它运行不了 它运行不了，不知道为什么 运行加，减之后后面就不输出了，想吐 思路是，创建两个链表头插法（方便计算），每一个节点储存一位数 加法是对应的位数相加，判断是否进位，向后循环 减法跟加法差不都，依次相减，判断是否向高位借1，结果符号要单独判断‘ 乘法使用两个循环，分别用一组数的每一位循环×另一组数的每一位，注意乘完放入的位次 除法先判断两数大小 a==b,a<b,直接输出结果 a>b,a=a-b直到a<b,减的次数是商，余数是a #include&.
git pull --rebase的理解
热门推荐
漆灿
08-08 2万+
在使用git的过程中经常需要使用到git pull命令，在更新远端代码的同时如果与本地代码产生冲突了， 那么冲突的文件中就出现了需要手动合并的部分，而git pull --rebase不同的地方则是当有这些冲突存在时， git帮我们自动创建了一个新的分支，并且git告诉你接下来你要在这个新的分支上处理这个冲突， 此时执行git status命令后可以看到首要的提示是这样的： rebase ...
PV操作
漆灿
09-16 1万+
三态模型 进程通常分为就绪、运行和阻塞三种工作状态。 三种状态在某些条件下可以转换，具体转换关系如下： 进程三个状态之间的转换是通过PV操作和信号量来控制的，其中信号量起到了很重要的作用。 信号量 信号量是最早出现的用来解决进程同步与互斥问题的机制。 信号量（Saphore）由一个值和一个指针组成，指针指向等待该信号量的进程，信号量的值表示相应资源的使用情况。 信号...
回调函数
漆灿
09-09 9688
回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。 其实回调就是一种利用函数指针进行函数调用的过程. 为什么要用回调呢?比如我要写一个子模块给你用,来接收远程socket发来的命令...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值