#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
using namespace std;
// 大整数类型
class BigInt
{
public:
BigInt(string str) :strDigit(str) {}
BigInt operator=(const BigInt &src)//赋值运算符的重载
{
return BigInt(this->strDigit = src.strDigit);
}
private:
string strDigit; // 使用字符串存储大整数
friend ostream& operator<<(ostream &out, const BigInt &src);
friend BigInt operator+(const BigInt &lhs, const BigInt &rhs);
friend BigInt operator-(const BigInt &lhs, const BigInt &rhs);
friend bool isBig(const BigInt & lhs, const BigInt & rhs);
};
// 打印函数
ostream& operator<<(ostream &out, const BigInt &src)
{
out << src.strDigit;
return out;
}
bool isBig(const BigInt & lhs, const BigInt & rhs)//判断两个大数的大小
{
int llen = lhs.strDigit.length();
int rlen = rhs.strDigit.length();
if (llen > rlen)
{
return true;
}
else if (llen < rlen)
{
return false;
}
else//长度相同,按位比较
{
if (lhs.strDigit >= rhs.strDigit)
{
return true;
}
else
{
return false;
}
}
}
int main()
{
BigInt int1("9785645649886874535428765");
BigInt int2("28937697857832167849697653231243");
BigInt int3("9785645649886874535428765");
//28937707643477817736572188660008
//28937707643477817736572188660008
cout << int1 + int2 << endl;
//28937688072186517962823117802478
//28937688072186517962823117802478
cout << int1 - int2 << endl;
return 0;
}
大数的加法
- 遍历字符串l,r,从后往前遍历
- 同位置的数字相加, 进位 flag 存入一个结果当中 string result
- 同时完成、某个字符串先完成 都要考虑进位
// 大数加法
BigInt operator+(const BigInt &lhs, const BigInt &rhs)
{
/*
t
*/
string result;
bool flag = false;
int size1 = lhs.strDigit.length() - 1;
int size2 = rhs.strDigit.length() - 1;
int i = size1, j = size2;
for (; i >= 0 && j >= 0; --i, --j)
{
int ret = lhs.strDigit[i] - '0' + rhs.strDigit[j] - '0';
if (flag)
{
ret += 1;
flag = false;
}
if (ret >= 10)
{
ret %= 10;
flag = true;
}
result.push_back(ret + '0');
}
// i j
if (i >= 0)
{
while (i >= 0)
{
int ret = lhs.strDigit[i] - '0';
if (flag)
{
ret += 1;
flag = false;
}
if (ret >= 10)
{
ret %= 10;
flag = true;
}
result.push_back(ret + '0');
i--;
}
}
else if (j >= 0)
{
while (j >= 0)
{
int ret = rhs.strDigit[j] - '0';
if (flag)
{
ret += 1;
flag = false;
}
if (ret >= 10)
{
ret %= 10;
flag = true;
}
result.push_back(ret + '0');
j--;
}
}
if (flag)
{
result.push_back('1');
}
reverse(result.begin(), result.end());
return result; // return BigInt(result);
}
大数的减法
-
找大的字符串做被减数,小的做减数
-
遍历两个字符串,减法,借位(bool flag), string result 存下来
-
长度大的字符串减去长度小的字符串,小的字符串遍历完,对于大字符串要考虑借位
-
长度相等的字符串进行减法,最后不用考虑借位,直接用大数减去小数,前边添“-”
// 大数减法
BigInt operator-(const BigInt &lhs, const BigInt &rhs)
{
string result;
bool flag = false;
bool minor = false;
string maxStr = lhs.strDigit;
string minStr = rhs.strDigit;
if (maxStr.length() < minStr.length())
{
maxStr = rhs.strDigit;
minStr = lhs.strDigit;
minor = true;
}
else if (maxStr.length() == minStr.length())
{
if (maxStr < minStr)
{
maxStr = rhs.strDigit;
minStr = lhs.strDigit;
minor = true;
}
else if (maxStr == minStr)
{
return string("0");
}
}
else
{
;
}
int size1 = maxStr.length() - 1;
int size2 = minStr.length() - 1;
int i = size1, j = size2;
for (; i >= 0 && j >= 0; --i, --j)
{
int ret = maxStr[i] - minStr[j];
if (flag)
{
ret -= 1;
flag = false;
}
if (ret < 0)
{
ret += 10;
flag = true;
}
result.push_back(ret + '0');
}
while (i >= 0)
{
int ret = maxStr[i]-'0';
if (flag)
{
ret -= 1;
flag = false;
}
if (ret < 0)
{
ret += 10;
flag = true;
}
result.push_back(ret + '0');
i--;
}
if (minor)
{
result.push_back('-');
}
reverse(result.begin(), result.end());
string result1;
int flag1 = 0;
for (int i = 0; i < result.size();)
{
if (result[0] == '-')
{
result1.push_back('-');
i++;
}
while (result[i] == '0'&&flag1==0&& i < result.size())//去掉前边的0
{
i++;
}
flag1 = 1;
result1.push_back(result[i]);
i++;
}
return result1;
}
大数的乘法
//乘法
BigInt operator*(const BigInt &lhs, const BigInt &rhs)
{
int len1 = lhs.strDigit.size();
int len2 = rhs.strDigit.size();
vector<int> vec(len1+len2,0);
string result;
for (int i = 0; i < len1; i++)
{
for (int j = 0; j < len2; j++)
{
vec[i + j + 1] += (lhs.strDigit[i]-'0') * (rhs.strDigit[j]-'0');
}
}
int len3 = vec.size();
for (int i = len3 - 1; i >= 0; --i)
{
if (vec[i] >= 10)
{
vec[i - 1] += vec[i] / 10;
vec[i] = vec[i] % 10;
}
}
for (int i = 0; i < len3; ++i)
{
result.push_back(vec[i] + '0');
}
return result;
}
大数的除法
基本思想: 利用减法操作来实现,反复做除法,看从被除数里面最多能减去多少个除数,商就是多少。逐个减显然太慢,要判断一次最多能减少多少个整数(除数)的10的n次方。
- 被除数小于除数,直接返回0
- 计算两个数的长度之差
- 给除数第一次加上长度之差r个0每次计算减的次数,并将次数加r个零添加进容器
- 第一次循环之后的差作为第二次循环的被减数,给除数加r-1个0,计算减的次数,并将次数加r-1个0添加进容器
- 依次类推
- 最后将容器中的元素全部进行相加,即为所得的商
以7546除以23为例:
先用7546减去23的100倍,即减去2300,可以减3次,余下646,此时商就是300 (300=100*3);
然后646减去23的10倍,即减去230,可以减2次,余下186,此时商就是320 (320=300+10*2);
然后186减去23,可以减8次,余下2,此时商就是328 (328=320+1*8);
因为2除以23的结果小于1,不用计算小数点位,所以不必再继续算下去了。
BigInt operator/(const BigInt &lhs, const BigInt &rhs)
{
if (lhs.strDigit == rhs.strDigit)//被除数和除数相等直接返回1
{
return string("1");
}
if (!isBig(lhs, rhs))//除数大于被除数
{
return string("0");
}
//一般情况:被除数大于除数
//得到长度差
int lendiffer = lhs.strDigit.length() - rhs.strDigit.length();
vector<BigInt>resvec;//存放结果的容器
BigInt lhstmp = lhs;
//开始循环
for (;lendiffer >= 0; --lendiffer)
{
BigInt rhstmp = rhs;
int k = lendiffer;
while (k > 0)//给被除数添加0
{
rhstmp.strDigit+= '0';
k--;
}
BigInt result("");//保存每次减完的结果
BigInt count("");//记录次数
//判断添完0之后的除数,如果大于被除数,代表一次都不能减
if (isBig(rhstmp.strDigit, lhstmp.strDigit))
{
rhstmp= rhs;//进行下一次的运算???
continue;
}
//如果被除数大于添加完0之后的除数, 代表至少可以减一次
do
{
result = lhstmp - rhstmp;
if (!isBig(result,rhstmp))//减完之后的结果小于减数,停止运算
{
lhstmp= result;
count = count + BigInt("1");
break;
}
lhstmp= result;
count = count + BigInt("1");
} while (isBig(result.strDigit, rhstmp.strDigit));
k = lendiffer;//恢复k的值,给次数加0
while (k > 0)
{
count.strDigit.push_back('0');
k--;
}
//将第一轮的结果添加进容器中
resvec.push_back(count);
}
BigInt res("");//保存商
for (int i = 0; i < resvec.size(); ++i)
{
res = res + resvec[i];
}
return res;
}