一个大整数运算类源码(BigInt)

本文介绍了大整数运算的实现,包括加减乘操作,并提出了采用万进制来提高运算效率。此外,还讨论了次方运算的优化算法,即指数化为二进制进行拆分计算。文中提供了C++实现的BigInt类,包含了大整数的存储、比较和转换等方法。并展示了如何通过BigInt类进行大整数的运算和性能测试。
摘要由CSDN通过智能技术生成

 

本文提供大整数的运算,包含加减乘,次方,阶乘的运算。

基本算法:

        大整数运算的基本算法比较简单,很多书上都有介绍,本文有一点要说明,本文采用的是万进制来运算。为什么采用万进制?因为万进制一个int字长可容纳4数字,这样就减少存储空间,同时大大提高了运算速度。照此说法还不如采用亿进制,原因在于乘法运算的过程中需要用到两个数相乘,而两个小于一万的数相乘小于一亿,也小于21亿,符合一个int字长,而采用亿进制会造成越界,处理起来麻烦,费时。

        次方运算采用了优化算法,实际上采用的是将指数化成二进制,然后拆开运算后相加得到结果。

        阶乘运算基本未使用优化策略,采用传统的递推算法。

代码:

 //
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <time.h>
#include <stdlib.h>
class BigInt
{
private:
    int sign;
    int nb;
    int *pData;
    void Init(int nnb);
    void ShowData(int m);
public:
    BigInt();
    BigInt(BigInt &bnum);
    BigInt(int num);
    ~BigInt();
    void Show();//控制台显示
    void trim();//规范化
    BigInt &operator=(int num);
    BigInt &operator=(BigInt &bnum);
    int operator==(BigInt &bnum);
    int operator!=(BigInt &bnum);
    int operator>(BigInt &bnum);
    int operator<(BigInt &bnum);
    int operator>=(BigInt &bnum);
    int operator<=(BigInt &bnum);
    BigInt &operator+=(BigInt &bnum);
    BigInt &operator-=(BigInt &bnum);
    BigInt &operator*=(BigInt &bnum);
    int GetBit();//获取位数
    int GetSign();//获取符号
    void Cont();//相反数
    int ReadFromStr(char *str);//数字字符串转换为BigInt
    int WriteToStr(char *str);//转变为字符串
    friend BigInt operator-(BigInt &bnum);
};
BigInt::BigInt()
{
    sign=0;
    nb=1;
    pData=new int[nb];
    pData[0]=0;
}
BigInt::BigInt(BigInt &bnum)
{
    sign=bnum.sign;
    nb=bnum.nb;
    pData=new int[nb];
    for(int i=0;i<nb;i++)
    pData[i]=bnum.pData[i];
}
BigInt::BigInt(int num)
{
    *this=num;
}
BigInt::~BigInt()
{
    delete []pData;
}
void BigInt::Init(int nnb)
{
    delete []pData;
    nb=nnb;
    pData=new int[nb];
    for(int i=0;i<nb;i++)
    pData[i]=0;
}
void BigInt::ShowData(int m)
{
    printf("%c%c%c%c",pData[m]/1000+'0',(pData[m]%1000)/100+'0',(pData[m]%100)/10+'0',pData[m]%10+'0');
}
void BigInt::Show()//控制台显示
{
    int i;
    if(sign==-1)
    printf("-");
    for(i=nb-1;i>=0;i--)
    {
        ShowData(i);
    }
}
void BigInt::trim()//规范化
{
    int i,j;
    for(i=nb-1;i>0;i--)
    {
        if(pData[i]!=0)
        break;
    }
    if(i==nb-1)
    return;
    BigInt bnum=*this;
    Init(i+1);
    for(j=0;j<=i;j++)
    {
        pData[j]=bnum.pData[j];
    }
}
BigInt &BigInt::operator=(int num)
{
    int n=abs(num);
    if(num==0)
    sign=0;
    else if(num>0)
    sign=1;
    else
    sign=-1;
    if(n<10000)
    {
        Init(1);
        pData[0]=n;
    }
    else if(n<100000000)
    {
        Init(2);
        pData[1]=n/10000;
        pData[0]=n%10000;
    }
    else
    {
        Init(3);
        pDat

好的,我可以为您解答。为了实现用链表储存超大整数并进行运算,我们可以创建一个来表示这个超大整数。以下是一个简单的 C++ 代码示例,用于实现这个: ```cpp #include <iostream> #include <string> using namespace std; // 链表节点定义 struct ListNode { int val; ListNode* next; ListNode(int x) : val(x), next(NULL) {} }; // 超大整数定义 class BigInt { private: ListNode* head; // 链表头指针 public: BigInt() : head(NULL) {} // 构造函数,初始化链表头指针为空 BigInt(string str) : head(NULL) { // 构造函数,根据字符串初始化链表 for (int i = str.size() - 1; i >= 0; i--) { ListNode* node = new ListNode(str[i] - '0'); node->next = head; head = node; } } // 拷贝构造函数,用于拷贝一个 BigInt 对象 BigInt(const BigInt& other) : head(NULL) { ListNode* cur = other.head; while (cur != NULL) { ListNode* node = new ListNode(cur->val); node->next = head; head = node; cur = cur->next; } } // 析构函数,释放链表内存 ~BigInt() { ListNode* cur = head; while (cur != NULL) { ListNode* next = cur->next; delete cur; cur = next; } } // 重载加号运算符,实现两个 BigInt 对象的加法运算 BigInt operator+(const BigInt& other) const { BigInt sum; ListNode* p = head, * q = other.head; int carry = 0; while (p != NULL || q != NULL) { int x = (p != NULL) ? p->val : 0; int y = (q != NULL) ? q->val : 0; int s = x + y + carry; carry = s / 10; ListNode* node = new ListNode(s % 10); node->next = sum.head; sum.head = node; if (p != NULL) p = p->next; if (q != NULL) q = q->next; } if (carry > 0) { ListNode* node = new ListNode(carry); node->next = sum.head; sum.head = node; } return sum; } // 重载输出运算符,用于将 BigInt 对象输出到标准输出流中 friend ostream& operator<<(ostream& os, const BigInt& num) { ListNode* cur = num.head; while (cur != NULL) { os << cur->val; cur = cur->next; } return os; } }; int main() { BigInt a("12345678901234567890"); BigInt b("98765432109876543210"); BigInt c = a + b; cout << c << endl; return 0; } ``` 在这个示例中,我们创建了一个名为 `BigInt` 的,用于表示超大整数。这个的数据成员是一个链表头指针,每个节点包含一个整数。我们在中实现了构造函数、拷贝构造函数、析构函数、重载加号运算符和输出运算符。 在 `operator+` 函数中,我们使用了链表的基本操作,遍历两个链表并逐位相加,得到一个新的链表表示结果。在 `operator<<` 函数中,我们使用了输出流操作符 `<<`,将链表中的整数逐位输出到标准输出流中。 最后,在 `main` 函数中,我们创建了两个超大整数,并进行了加法运算,将结果输出到标准输出流中。
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值