精华内容
下载资源
问答
  • 大数加减

    2019-08-10 17:43:05
    #include "iostream" #include "string" using namespace std; struct bign { int d[1000]; int len; bign() {//构造函数 memset(d, 0, sizeof(d));//赋初值为0 len = 0;...bign Add(big...
    #include "iostream"
    #include "string"
    using namespace std;
    struct bign {
    	int d[1000];
    	int len;
    	bign() {//构造函数
    		memset(d, 0, sizeof(d));//赋初值为0
    		len = 0;
    	}
    };
    bign change(string a);
    bign Add(bign a,bign b);
    int Judge(bign a, bign b);//判断大小,a>b返回1 a<b返回0 相等返回-1
    bign Sub(bign a, bign b);
    void Print(bign c);
    int main()
    {
    	string a,b;
    	cin>>a>>b;
    	bign A=change(a);
    	bign B = change(b);
    	bign C = Add(A, B);
    	cout << "相加的结果" << endl;
    	Print(C);
    	int judge = Judge(A, B);
    	cout<< "相减的结果" << endl;
    	if (judge == 1)
    	{
    		bign D = Sub(A, B);
    		Print(D);
    	}
    	else if (judge == 0)
    	{
    		bign D = Sub(B, A);
    		cout << "-";
    		Print(D);
    	}
    	else
    		cout << "相减等于0";
    	system("pause");
    	return 0;
    }
    //整数的高位存储在数组的高位
    bign change(string a)
    {
    	bign temp;
    	for (int i = 0; i < a.size(); i++)
    	{
    		temp.d[i] = a[a.size() - 1 - i] - '0';
    	}
    	temp.len = a.size();
    	return temp;
    }
    bign Add(bign a,bign b)
    {
    	bign c;
    	int jinwei = 0;
    	for (int i = 0; i < 1000; i++)
    	{
    		int temp = a.d[i] + b.d[i]+jinwei;
    		c.d[i] = c.d[i]+temp % 10;
    		jinwei = temp / 10;//存储着进位
    	}
    	int num = 0;
    	for (int i = 999; i >= 0; i--)
    	{
    		if (c.d[i] != 0)
    			break;
    		if (c.d[i] == 0)
    			num++;
    	}
    	c.len = 1000 - num;
    	return c;
    }
    bign Sub(bign a, bign b)
    {
    	bign c;
    	for (int i = 0; i < a.len; i++)
    	{
    		if (a.d[i] < b.d[i])
    		{
    			a.d[i] = a.d[i] + 10;
    			a.d[i + 1]--;//借位
    			c.d[i] = a.d[i] - b.d[i];
    		}else
    			c.d[i] = a.d[i] - b.d[i];
    	}
    	int num = 0;
    	for (int i = 999; i >= 0; i--)
    	{
    		if (c.d[i] != 0)
    			break;
    		if (c.d[i] == 0)
    			num++;
    	}
    	c.len = 1000 - num;
    	return c;
    }
    int Judge(bign a, bign b)
    {
    	if (a.len > b.len)
    		return 1;
    	else if (a.len < b.len)
    		return 0;
    	else if (a.len = b.len)
    	{
    		for (int i = 0; i < 1000; i++)
    		{
    			if (a.d[i] > b.d[i])
    			{
    				return 1;
    			}
    			else if (a.d[i] < b.d[i])
    			{
    				return 0;
    			}
    		}
    	}
    	return -1;
    }
    void Print(bign c)
    {
    	for (int i = c.len - 1; i >= 0; i--)
    		cout << c.d[i];
    	cout << endl;
    }

     

    展开全文
  • 大数加减优化

    2021-01-19 00:43:41
    大数加减优化一、大数加减的代码大数相加大数相减二、大数加减编程题AcWing 791. 高精度加法AcWing 792. 高精度减法 一、大数加减的代码 大数相加 vector<int> add(vector<int> &A, vector<int&...


    一、大数加减的代码

    大数相加

    vector<int> add(vector<int> &A, vector<int> &B)
    {
        if (A.size() < B.size()) return add(B, A);
        vector<int> C;
        int t = 0;
        for (int i = 0; i < A.size(); i ++ )
        {
            t += A[i];
            if (i < B.size()) t += B[i];
            C.push_back(t % 10);
            t /= 10;
        }
    
        if (t) C.push_back(t);
        return C;
    }
    

    大数相减

    // C = A - B, 满足A >= B, A >= 0, B >= 0
    vector<int> sub(vector<int> &A, vector<int> &B)
    {
        vector<int> C;
        for (int i = 0, t = 0; i < A.size(); i ++ )
        {
            t = A[i] - t;
            if (i < B.size()) t -= B[i];
            C.push_back((t + 10) % 10);
            if (t < 0) t = 1;
            else t = 0;
        }
    
        while (C.size() > 1 && C.back() == 0) C.pop_back();
        return C;
    }
    

    二、大数加减编程题

    AcWing 791. 高精度加法

    #include<bits/stdc++.h>
    using namespace std;
    
    vector<int> add(vector<int> &A, vector<int> &B)
    {
        if (A.size() < B.size()) return add(B, A);
        vector<int> C;
        int t = 0;
        for (int i = 0; i < A.size(); i ++ )
        {
            t += A[i];
            if (i < B.size()) t += B[i];
            C.push_back(t % 10);
            t /= 10;
        }
    
        if (t) C.push_back(t);
        return C;
    }
    int main()
    {
    	string a,b;
    	cin>>a>>b;
    	vector<int> A;
    	vector<int> B;
    	for(int i=a.size()-1;i>=0;i--) A.push_back(a[i]-'0');
    	for(int i=b.size()-1;i>=0;i--) B.push_back(b[i]-'0');
    	vector<int> C=add(A,B);
    	for(int i=C.size()-1;i>=0;i--) printf("%d",C[i]);
    
    	return 0;
    }
    
    
    

    AcWing 792. 高精度减法

    #include<bits/stdc++.h>
    using namespace std;
    
    //判断A>=B
    bool cmp(vector<int> &A,vector<int> &B)
    {
    	if(A.size()!=B.size()) return A.size()>B.size();
    	for(int i=A.size()-1;i>=0;i--)
    	{
    		if(A[i]!=B[i])
    		{
    			return A[i]>B[i];
    		}
    	}
    	return true;
    }
     
    // C = A - B, 满足A >= B, A >= 0, B >= 0
    vector<int> sub(vector<int> &A, vector<int> &B)
    {
        vector<int> C;
        for (int i = 0, t = 0; i < A.size(); i ++ )
        {
            t = A[i] - t;
            if (i < B.size()) t -= B[i];
            C.push_back((t + 10) % 10);
            if (t < 0) t = 1;
            else t = 0;
        }
    
        while (C.size() > 1 && C.back() == 0) C.pop_back();
        return C;
    }
    
    int main()
    {
    	string a,b;
    	cin>>a>>b;
    	vector<int> A;
    	vector<int> B;
    	for(int i=a.size()-1;i>=0;i--) A.push_back(a[i]-'0');
    	for(int i=b.size()-1;i>=0;i--) B.push_back(b[i]-'0');
    	
    	if(cmp(A,B))
    	{
    		vector<int> C=sub(A,B);
    		for(int i=C.size()-1;i>=0;i--) printf("%d",C[i]);
    	}
    	else
    	{
    		vector<int> C=sub(B,A);
    		printf("-"); 
    		for(int i=C.size()-1;i>=0;i--) printf("%d",C[i]);
    	}
    
    	return 0;
    }
    
    
    

    展开全文
  • C++大数加减

    2014-10-14 16:00:43
    用c++实现大数加减乘,绝对可以实现。希望分享
  • java 数组实现大数加减乘除运算 下载 算法思想很简单,都是我自己做的,相信肯花时间每个人都可以写出来更好的。
  • 整数的大数加减

    千次阅读 2017-10-26 07:09:00
    萌新的整数大数加减

    萌新的整数大数加减


    大致思路:

    1. 数据输入         将数据存入字符数组 运算符号存入字符。

    2. 整数正负判断  使用strlen()函数将两组字符串长度存入整形变量len,之后判断数据是否为负,是则长度减一并且使用一整型变量存储正负数据。

    3. 数据类型转换  倒叙将字符数组转为整型数组。

    4. 判断运算类型  

    5. 输出符号判断

    6. 数据运算         加法运算直接模拟竖式计算;减法运算使被减数在两组数据最高位后一位补一,再相减(如456-789转换为1456-789=0667),如果最高位后一位为1直接输出,否则(即为0)使最高位为1其余为0减去结果(1000-0667=333)。

    7. 输出运算结果  找到第一个不为0的数开始输出,全0则输出0。


    分割线

    2018.10.30 代码有点bug,应该是第43行没处理好,懒得改了


    #include<stdio.h>
    #include<math.h>
    #include<string.h>
    #include<stdlib.h>
    #include<algorithm>
    using namespace std;
    
    char str1[1010],str2[1010];
    int v1[1010],v2[1010],range=1000+1;             //range为计算位数+1
    
    void add(int len)                               //加法运算
    {
        int i;
        for(i=range-1;i>=len;i--)                   //倒叙相加逢十进一
        {
            v1[i]+=v2[i];
            if(v1[i]>9)
            {
                v1[i]-=10;
                v1[i-1]++;
            }
        }
        if(v1[len-1]!=0)printf("%d",v1[len-1]);     //判断最高位下一位是否为0
        for(i=len;i<range;i++)
            printf("%d",v1[i]);                     //输出
        printf("\n");
    }
    
    void sub(int len,int flag1)                     //减法运算
    {
        int i,sign=1;                               //sign >0为正 =0为0 <0为负
        if(v1[len]==v2[len])                        //判断数据结果是否为负或0
        {
            for(i=len+1;i<range;i++)
            {
                if(v1[i]!=v2[i])
                    sign=(v1[i]-v2[i])*flag1;
            }
            if(i==range)sign=0;
        }
        else sign=(v1[len]-v2[len])*flag1;
        if(sign<0)printf("-");
        if(sign==0)printf("0");
        v1[len-1]=1;                                //最高位前一位补1
        for(i=range-1;i>=len;i--)                   //相减结果存入v1
        {
            v1[i]-=v2[i];
            if(v1[i]<0)
            {
                v1[i]+=10;
                v1[i-1]--;
            }
        }
        if(v1[len-1]==1)                            //最高位前一位未被借位
            {
                for(i=len;i<range;i++)
                    if(v1[i]!=0)break;
                for(;i<range;i++)                   //输出
                    printf("%d",v1[i]);
            }
        else                                        //具体见思路6
        {                                           //结果存入v2
            memset(v2,0,sizeof(v2));
            v2[len-1]=1;
            for(i=range-1;i>=len;i--)
            {
                v2[i]-=v1[i];
                if(v2[i]<0)
                {
                    v2[i]+=10;
                    v2[i-1]--;
                }
            }
            for(i=len;i<range;i++)
                if(v2[i]!=0)break;
            for(;i<range;i++)                       //输出
                printf("%d",v2[i]);
        }
        printf("\n");
    }
    
    int main()
    {
        int i,j;
        char sign;
        while(~scanf("%s %c %s",&str1,&sign,&str2))
        {
            int len1=strlen(str1),len2=strlen(str2),flag1=1,flag2=1,j1=0,j2=0;
            if(str1[0]=='-')        //flag存数据正负 len存长度 j存从第几位开始转换
            {
                j1++;
                len1--;
                flag1=-1;
            }
            if(str2[0]=='-')
            {
                j2++;
                len2--;
                flag2=-1;
            }
            for(i=range-len1,j=j1;i<range;i++)
                v1[i]=str1[j++]-'0';
            for(i=range-len2,j=j2;i<range;i++)
                v2[i]=str2[j++]-'0';
            if(sign=='+')
            {
                if(flag1*flag2==-1)
                {
                    sub(min(range-len1,range-len2),flag1);      //正+负  负+正
                }
                else
                {
                    if(flag1==-1)
                    {
                        printf("-");
                        add(min(range-len1,range-len2));        //负+负
                    }
                    else
                        add(min(range-len1,range-len2));        //正+正
                }
            }
            if(sign=='-')
            {
                if(flag1*flag2==1)
                {
                    sub(min(range-len1,range-len2),flag1);       //正-正 负-负
                }
                if(flag1*flag2==-1)
                {
                    if(flag1==1)add(min(range-len1,range-len2));        //正-负
                    else {printf("-");add(min(range-len1,range-len2));} //负-正
                }
            }
            memset(v2,0,sizeof(v2));        //清零
            memset(v1,0,sizeof(v1));
            printf("\n");
        }
        return 0;
    }
    
    
    
    展开全文
  • 处理无符号大数加减 处理有符号大数加减 处理有符号大数加减 1.定义的结构体 struct Node { int digit; //数字 struct Node *next, *prev; //前后指针 }; struct UBigNumber { int digitCount; //位数 struct ...

    处理无符号大数加减

    处理有符号大数加减

    处理有符号大数加减

    1.定义的结构体

    struct Node
    {
        int digit;  //数字
        struct Node *next, *prev;  //前后指针
    };
    
    struct UBigNumber
    {
        int digitCount;  //位数
        struct Node *pHead, *pTail;  //指向头结点和尾结点
    };
    

    2.定义的函数:

    //动态分配1个结点,返回结点指针
    //当分配失败时,简化程序,退出运行
    struct Node *_NewNode();

    //表示无符号大数用带头结点的双向链表
    void _InitUBN(struct UBigNumber *pUBN);

    //输入无符号大数
    struct UBigNumber InputUBN();

    //无符号大数尾部添加1位数字
    void _AppendDigit(struct UBigNumber *pUBN, int digit);

    //无符号大数首部添加1位数字
    void _AppendFrontDigit(struct UBigNumber *pUBN, int digit);

    //无符号大数的规范表示,去除高位多余的0,至少含1位数字
    void _Normalize(struct UBigNumber *pUBN);

    //两个无符号大数相加
    struct UBigNumber AddUBN(struct UBigNumber *pA, struct UBigNumber *pB);

    //无符号整数相减
    struct UBigNumber SubUBN(struct UBigNumber *pA, struct UBigNumber *pB);

    //打印无符号大数
    void PrintUBN(struct UBigNumber ubn);

    //销毁无符号大数,释放空间
    void DestroyUBN(struct UBigNumber *pA);

    1. 函数实现代码:
    //动态分配1个结点,返回结点指针
    //当分配失败时,简化程序,退出运行
    struct Node *_NewNode()
    {
        struct Node *p;
        p = (struct Node*)malloc(sizeof(struct Node));
        if(p == NULL)  //分配失败
        {
            printf("Error:out of memory\n");
            exit(-1);  //简化程序,退出运行
        }
        return p;
    
    }
    
    
    //建立表示无符号大数用带头结点的双向链表
    void _InitUBN(struct UBigNumber *pUBN)
    {
        struct Node *p = _NewNode();
        pUBN->pHead = pUBN->pTail = p;  //建立头结点
        p->next = p->prev = NULL;
        pUBN->digitCount = 0;
    }
    
    
    //输入无符号大数
    struct UBigNumber InputUBN()
    {
        struct UBigNumber result;
        _InitUBN(&result);
    
        char ch;
        //跳过非数字字符
        do
            ch = getchar();
        while(ch < '0' || ch > '9');
        while(ch >= '0' && ch <= '9')
        {
            _AppendDigit(&result, ch-'0');  //添加1位
            ch = getchar();
        }
        _Normalize(&result);
        return result;
    }
    
    
    //无符号大数尾部添加1位数字
    void _AppendDigit(struct UBigNumber *pUBN, int digit)
    {  //原来只有一个高位0
        if(pUBN->digitCount == 1 && pUBN->pTail->digit == 0)
        {
            pUBN->pTail->digit = digit;  //位数不变,数值为0
            return;
        }
        struct Node *p = _NewNode();  //申请新结点
        p->digit = digit;  //设置结点数值
        p->next = NULL;  //修改双向链表,将新结点添加到尾部
        p->prev = pUBN->pTail;
        pUBN->pTail->next = p;
        pUBN->pTail = p;
        ++pUBN->digitCount;  //修改位数
    }
    
    
    //无符号大数首部添加1位数字
    void _AppendFrontDigit(struct UBigNumber *pUBN, int digit)
    {
        struct Node *p = _NewNode();  //申请新结点
        p->digit = digit;  //设置结点数值
        p->next = pUBN->pHead->next;  //修改双向链表,将新结点添加在头结点后
        if(p->next != NULL)
            p->next->prev = p;
        p->prev = pUBN->pHead;
        pUBN->pHead->next = p;
        if(pUBN->pTail == pUBN->pHead)
            pUBN->pTail = p;  //当原来只有头结点时,新结点也是尾结点
        ++pUBN->digitCount;  //修改位数
    }
    
    
    //无符号大数的规范表示,去除高位多余的0,至少含1位数字
    void _Normalize(struct UBigNumber *pUBN)
    {
        if(pUBN->digitCount == 0)
            _AppendDigit(pUBN, 0);
        while(pUBN->digitCount > 1 && pUBN->pHead->next->digit == 0)
        {   //去除高位多余的0
            struct Node *p;
            p = pUBN->pHead->next;  //待删除的结点
            pUBN->pHead->next = p->next;  //正向链表中删除
            p->next->prev = pUBN->pHead;  //反向链表中删除
            free(p);  //释放结点
            --pUBN->digitCount;  //调整位数
        }
    }
    
    
    //两个无符号大数相加
    struct UBigNumber AddUBN(struct UBigNumber *pA, struct UBigNumber *pB)
    {
        struct UBigNumber result, *pResult = &result;
        _InitUBN(pResult);
        int iCarry = 0;  //进位,初始0
        struct Node *p1, *p2;
        p1 = pA->pTail;  //从低位开始处理
        p2 = pB->pTail;
        while(p1 != pA->pHead && p2 != pB->pHead)  //两数相同位处理
        {
            int digit = p1->digit + p2->digit + iCarry;
            iCarry = digit / 10;  //新进位
            digit %= 10;  //当前结果位
            _AppendFrontDigit(pResult, digit);  //添加至结果最高位
            p1 = p1->prev;  //准备处理前一位
            p2 = p2->prev;
        }
        while(p1 != pA->pHead)  //第一位大数剩余位处理
        {
            int digit = p1->digit + iCarry;
            iCarry = digit / 10;
            digit %= 10;
            _AppendFrontDigit(pResult, digit);
            p1 = p1->prev;
        }
        while(p2 != pB->pHead)  //第二位大数剩余位处理
        {
            int digit = p2->digit + iCarry;
            iCarry = digit / 10;
            digit %= 10;
            _AppendFrontDigit(pResult, digit);
            p2 = p2->prev;
        }
        if(iCarry != 0)  //最后进位处理
            _AppendFrontDigit(pResult, iCarry);
        return result;
    }
    
    
    //两个无符号大数相减
    struct UBigNumber SubUBN(struct UBigNumber *pA, struct UBigNumber *pB)
    {
        struct UBigNumber result, *pResult = &result;
        _InitUBN(pResult);
        int iCarry = 0;  //退位,初始0
        struct Node *p1, *p2;
        p1 = pA->pTail;  //从低位开始处理
        p2 = pB->pTail;
        while(p1 != pA->pHead && p2 != pB->pHead)  //两数相同位处理
        {
            int digit = p1->digit - p2->digit - iCarry;
            iCarry = 0; //初始化
            if(digit < 0)
            {
                digit += 10;  
                iCarry = 1;  //前一位退1
            }
            _AppendFrontDigit(pResult, digit);
            p1 = p1->prev;
            p2 = p2->prev;
        }
        while(p1 != pA->pHead)  //最后退位处理
        {
            int digit = p1->digit - iCarry;
            iCarry = 0;
            if(digit < 0)
            {
                digit += 10;  
                iCarry = 1;  //前一位退1
            }
            _AppendFrontDigit(pResult, digit);
            p1 = p1->prev;
        }
        _Normalize(pResult);
        return result;
    }
    
    
    //打印无符号大数
    void PrintUBN(struct UBigNumber ubn)
    {  //断言:至少有1位数字
        assert(ubn.digitCount > 0 && ubn.pHead->next != NULL);
        struct Node *la = ubn.pHead->next;  //头结点无数据,跳过
        while(la)
        {
            printf("%d",la->digit);
            la = la->next;
        }
    }
    
    
    //销毁无符号大数,释放空间
    void DestroyUBN(struct UBigNumber *pUBN)
    {
        while(pUBN->pHead != NULL)
        {
            struct Node *p = pUBN->pHead;  //待删除结点
            pUBN->pHead = p->next;  //尾指针前移
            free(p);  //释放结点
        }
    }
    
    

    4.完整代码

    #include <stdio.h>
    #include <stdlib.h>
    #include <assert.h>
    #include <malloc.h>
    
    
    struct Node
    {
        int digit;  //数字
        struct Node *next, *prev;  //前后指针
    };
    
    struct UBigNumber
    {
        int digitCount;  //位数
        struct Node *pHead, *pTail;  //指向头结点和尾结点
    };
    
    
    //动态分配1个结点,返回结点指针
    //当分配失败时,简化程序,退出运行
    struct Node *_NewNode();
    //表示无符号大数用带头结点的双向链表
    void _InitUBN(struct UBigNumber *pUBN);
    //输入无符号大数
    struct UBigNumber InputUBN();
    //无符号大数尾部添加1位数字
    void _AppendDigit(struct UBigNumber *pUBN, int digit);
    //无符号大数首部添加1位数字
    void _AppendFrontDigit(struct UBigNumber *pUBN, int digit);
    //无符号大数的规范表示,去除高位多余的0,至少含1位数字
    void _Normalize(struct UBigNumber *pUBN);
    //两个无符号大数相加
    struct UBigNumber AddUBN(struct UBigNumber *pA, struct UBigNumber *pB);
    //无符号整数相减
    struct UBigNumber SubUBN(struct UBigNumber *pA, struct UBigNumber *pB);
    //打印无符号大数
    void PrintUBN(struct UBigNumber ubn);
    //销毁无符号大数,释放空间
    void DestroyUBN(struct UBigNumber *pA);
    
    
    int main()
    {
        struct UBigNumber A, B, C, D;
        A = InputUBN();
        B = InputUBN();
        C = AddUBN(&A, &B);
        D = SubUBN(&A, &B);
    
        PrintUBN(A);
        printf("+");
        PrintUBN(B);
        printf("=");
        PrintUBN(C);
        printf("\n");
    
        PrintUBN(A);
        printf("-");
        PrintUBN(B);
        printf("=");
        PrintUBN(D);
    
        DestroyUBN(&A);
        DestroyUBN(&B);
        DestroyUBN(&C);
        DestroyUBN(&D);
    
        return 0;
    }
    
    
    struct Node *_NewNode()
    {
        struct Node *p;
        p = (struct Node*)malloc(sizeof(struct Node));
        if(p == NULL)  //分配失败
        {
            printf("Error:out of memory\n");
            exit(-1);  //简化程序,退出运行
        }
        return p;
    
    }
    
    
    //建立表示无符号大数用带头结点的双向链表
    void _InitUBN(struct UBigNumber *pUBN)
    {
        struct Node *p = _NewNode();
        pUBN->pHead = pUBN->pTail = p;  //建立头结点
        p->next = p->prev = NULL;
        pUBN->digitCount = 0;
    }
    
    
    //输入无符号大数
    struct UBigNumber InputUBN()
    {
        struct UBigNumber result;
        _InitUBN(&result);
    
        char ch;
        //跳过非数字字符
        do
            ch = getchar();
        while(ch < '0' || ch > '9');
        while(ch >= '0' && ch <= '9')
        {
            _AppendDigit(&result, ch-'0');  //添加1位
            ch = getchar();
        }
        _Normalize(&result);
        return result;
    }
    
    
    //无符号大数尾部添加1位数字
    void _AppendDigit(struct UBigNumber *pUBN, int digit)
    {  //原来只有一个高位0
        if(pUBN->digitCount == 1 && pUBN->pTail->digit == 0)
        {
            pUBN->pTail->digit = digit;  //位数不变,数值为0
            return;
        }
        struct Node *p = _NewNode();  //申请新结点
        p->digit = digit;  //设置结点数值
        p->next = NULL;  //修改双向链表,将新结点添加到尾部
        p->prev = pUBN->pTail;
        pUBN->pTail->next = p;
        pUBN->pTail = p;
        ++pUBN->digitCount;  //修改位数
    }
    
    
    //无符号大数首部添加1位数字
    void _AppendFrontDigit(struct UBigNumber *pUBN, int digit)
    {
        struct Node *p = _NewNode();  //申请新结点
        p->digit = digit;  //设置结点数值
        p->next = pUBN->pHead->next;  //修改双向链表,将新结点添加在头结点后
        if(p->next != NULL)
            p->next->prev = p;
        p->prev = pUBN->pHead;
        pUBN->pHead->next = p;
        if(pUBN->pTail == pUBN->pHead)
            pUBN->pTail = p;  //当原来只有头结点时,新结点也是尾结点
        ++pUBN->digitCount;  //修改位数
    }
    
    
    //无符号大数的规范表示,去除高位多余的0,至少含1位数字
    void _Normalize(struct UBigNumber *pUBN)
    {
        if(pUBN->digitCount == 0)
            _AppendDigit(pUBN, 0);
        while(pUBN->digitCount > 1 && pUBN->pHead->next->digit == 0)
        {   //去除高位多余的0
            struct Node *p;
            p = pUBN->pHead->next;  //待删除的结点
            pUBN->pHead->next = p->next;  //正向链表中删除
            p->next->prev = pUBN->pHead;  //反向链表中删除
            free(p);  //释放结点
            --pUBN->digitCount;  //调整位数
        }
    }
    
    
    //两个无符号大数相加
    struct UBigNumber AddUBN(struct UBigNumber *pA, struct UBigNumber *pB)
    {
        struct UBigNumber result, *pResult = &result;
        _InitUBN(pResult);
        int iCarry = 0;  //进位,初始0
        struct Node *p1, *p2;
        p1 = pA->pTail;  //从低位开始处理
        p2 = pB->pTail;
        while(p1 != pA->pHead && p2 != pB->pHead)  //两数相同位处理
        {
            int digit = p1->digit + p2->digit + iCarry;
            iCarry = digit / 10;  //新进位
            digit %= 10;  //当前结果位
            _AppendFrontDigit(pResult, digit);  //添加至结果最高位
            p1 = p1->prev;  //准备处理前一位
            p2 = p2->prev;
        }
        while(p1 != pA->pHead)  //第一位大数剩余位处理
        {
            int digit = p1->digit + iCarry;
            iCarry = digit / 10;
            digit %= 10;
            _AppendFrontDigit(pResult, digit);
            p1 = p1->prev;
        }
        while(p2 != pB->pHead)  //第二位大数剩余位处理
        {
            int digit = p2->digit + iCarry;
            iCarry = digit / 10;
            digit %= 10;
            _AppendFrontDigit(pResult, digit);
            p2 = p2->prev;
        }
        if(iCarry != 0)  //最后进位处理
            _AppendFrontDigit(pResult, iCarry);
        return result;
    }
    
    
    //两个无符号大数相减
    struct UBigNumber SubUBN(struct UBigNumber *pA, struct UBigNumber *pB)
    {
        struct UBigNumber result, *pResult = &result;
        _InitUBN(pResult);
        int iCarry = 0;  //退位,初始0
        struct Node *p1, *p2;
        p1 = pA->pTail;  //从低位开始处理
        p2 = pB->pTail;
        while(p1 != pA->pHead && p2 != pB->pHead)  //两数相同位处理
        {
            int digit = p1->digit - p2->digit - iCarry;
            iCarry = 0; //初始化
            if(digit < 0)
            {
                digit += 10;  
                iCarry = 1;  //前一位退1
            }
            _AppendFrontDigit(pResult, digit);
            p1 = p1->prev;
            p2 = p2->prev;
        }
        while(p1 != pA->pHead)  //最后退位处理
        {
            int digit = p1->digit - iCarry;
            iCarry = 0;
            if(digit < 0)
            {
                digit += 10;  
                iCarry = 1;  //前一位退1
            }
            _AppendFrontDigit(pResult, digit);
            p1 = p1->prev;
        }
        _Normalize(pResult);
        return result;
    }
    
    
    //打印无符号大数
    void PrintUBN(struct UBigNumber ubn)
    {  //断言:至少有1位数字
        assert(ubn.digitCount > 0 && ubn.pHead->next != NULL);
        struct Node *la = ubn.pHead->next;  //头结点无数据,跳过
        while(la)
        {
            printf("%d",la->digit);
            la = la->next;
        }
    }
    
    
    //销毁无符号大数,释放空间
    void DestroyUBN(struct UBigNumber *pUBN)
    {
        while(pUBN->pHead != NULL)
        {
            struct Node *p = pUBN->pHead;  //待删除结点
            pUBN->pHead = p->next;  //尾指针前移
            free(p);  //释放结点
        }
    }
    
    
    

    处理有符号大数加减

    1. 定义的函数(与无符号相比有修改或增加的函数)

    //输入有符号大数
    struct UBigNumber InputUBN();

    //大数绝对值比较大小
    int CmpUBN(struct UBigNumber *pA, struct UBigNumber *pB);

    //打印有符号大数
    void PrintUBN(struct UBigNumber ubn);

    1. 函数的实现
    //输入有符号大数
    struct UBigNumber InputUBN()
    {
        struct UBigNumber result;
        _InitUBN(&result);
    
        char ch;
        do
        {
            ch = getchar();
            if(ch == '-')
            {
                result.pHead->digit = '-';  //存储负号
                ch = getchar();
                break;
            }
            else
                result.pHead->digit = '+';  //存储正号
        }while(ch < '0' || ch > '9');
        while(ch >= '0' && ch <= '9')
        {
            _AppendDigit(&result, ch-'0');
            ch = getchar();
        }
        _Normalize(&result);
        return result;
    }
    
    //两个大数绝对值比较大小
    int  CmpUBN(struct UBigNumber *pA, struct UBigNumber *pB)
    {
        struct Node *p1, *p2;
        //先比较位数
        if(pA->digitCount > pB->digitCount)
            return 0;  //0标记pA大于等于pB
        else
        {
            p1 = pA->pHead->next;
            p2 = pB->pHead->next;
            while(p1 != NULL)  //位数相同,只需判断p1与p2其中一个即可
            {
                if(p1 < p2)
                    return 1;//1标记pA小于pB
                p1 = p1->next;
                p2 = p2->next;
            }
        }
        return 0;  //pA与pB相等
    }
    
    //打印有符号大数
    void PrintUBN(struct UBigNumber ubn)
    {
        assert(ubn.digitCount > 0 && ubn.pHead->next != NULL);
        //若负数,打印负号
        if(ubn.pHead->digit == '-')
            printf("%c", ubn.pHead->digit);
        //打印数字
        struct Node *la = ubn.pHead->next;
        while(la)
        {
            printf("%d",la->digit);
            la = la->next;
        }
    }
    
    1. 完整代码
    #include <stdio.h>
    #include <stdlib.h>
    #include <assert.h>
    #include <malloc.h>
    
    
    struct Node
    {
        int digit;  //数字
        struct Node *next, *prev;  //前后指针
    };
    
    struct UBigNumber
    {
        int digitCount;  //位数
        struct Node *pHead, *pTail;  //指向头结点和尾结点
    };
    
    //动态分配1个结点,返回结点指针
    //当分配失败时,简化程序,退出运行
    struct Node *_NewNode();
    //表示大数用带头结点的双向链表
    void _InitUBN(struct UBigNumber *pUBN);
    //输入有符号大数
    struct UBigNumber InputUBN();
    //大数尾部添加1位数字
    void _AppendDigit(struct UBigNumber *pUBN, int digit);
    //大数首部添加1位数字
    void _AppendFrontDigit(struct UBigNumber *pUBN, int digit);
    //大数的规范表示,去除高位多余的0,至少含1位数字
    void _Normalize(struct UBigNumber *pUBN);
    //大数绝对值比较大小
    int  CmpUBN(struct UBigNumber *pA, struct UBigNumber *pB);
    //两个有符号大数相加
    struct UBigNumber AddUBN(struct UBigNumber *pA, struct UBigNumber *pB);
    //无符号整数相减
    struct UBigNumber SubUBN(struct UBigNumber *pA, struct UBigNumber *pB);
    //打印有符号大数
    void PrintUBN(struct UBigNumber ubn);
    //销毁有符号大数,释放空间
    void DestroyUBN(struct UBigNumber *pA);
    
    
    int main()
    {
        struct UBigNumber A, B, C, D;
        A = InputUBN();
        B = InputUBN();
        //输入两个正数
        if(A.pHead->digit == '+' && B.pHead->digit == '+') 
        {
            if(CmpUBN(&A, &B))
            {   //A绝对值比B绝对值小
                C = AddUBN(&A, &B);
                C.pHead->digit = '+';
                D = SubUBN(&B, &A);
                D.pHead->digit = '-';
            }
            else
            {
                C = AddUBN(&A, &B);
                C.pHead->digit = '+';
                D = SubUBN(&A, &B);
                D.pHead->digit = '+';
            }
    
        }
        //输入第一个正数,第二个负数
        else if(A.pHead->digit == '+' && B.pHead->digit == '-')
        {
           if(CmpUBN(&A, &B))
            {   //A绝对值比B绝对值小
                C = SubUBN(&B, &A);
                C.pHead->digit = '-';
                D = AddUBN(&B, &A);
                D.pHead->digit = '+';
            }
            else
            {
                C = SubUBN(&A, &B);
                C.pHead->digit = '+';
                D = AddUBN(&A, &B);
                D.pHead->digit = '+';
            }
        }
        //输入第一个负数,第二个正数
        else if(A.pHead->digit == '-' && B.pHead->digit == '+')
        {
           if(CmpUBN(&A, &B))
            {   //A绝对值比B绝对值小
                C = SubUBN(&B, &A);
                C.pHead->digit = '+';
                D = AddUBN(&B, &A);
                D.pHead->digit = '-';
            }
            else
            {
                C = SubUBN(&A, &B);
                C.pHead->digit = '-';
                D = AddUBN(&A, &B);
                D.pHead->digit = '-';
            }
        }
        //输入第一个负数,第二个负数
        else if(A.pHead->digit == '-' && B.pHead->digit == '-')
        {
           if(CmpUBN(&A, &B))
            {   //A绝对值比B绝对值小
                C = AddUBN(&B, &A);
                C.pHead->digit = '-';
                D = SubUBN(&B, &A);
                D.pHead->digit = '+';
            }
            else
            {
                C = AddUBN(&A, &B);
                C.pHead->digit = '-';
                D = SubUBN(&A, &B);
                D.pHead->digit = '-';
            }
        }
    
    
        PrintUBN(C);
    
        printf("\n");
    
        PrintUBN(D);
    
        DestroyUBN(&A);
        DestroyUBN(&B);
        DestroyUBN(&C);
        DestroyUBN(&D);
    
        return 0;
    }
    
    
    //动态分配1个结点,返回结点指针
    //当分配失败时,简化程序,退出运行
    struct Node *_NewNode()
    {
        struct Node *p;
        p = (struct Node*)malloc(sizeof(struct Node));
        if(p == NULL)
        {
            printf("Error:out of memory\n");
            exit(-1);
        }
        return p;
    
    }
    
    
    //表示大数用带头结点的双向链表
    void _InitUBN(struct UBigNumber *pUBN)
    {
        struct Node *p = _NewNode();
        pUBN->pHead = pUBN->pTail = p;
        p->next = p->prev = NULL;
        pUBN->digitCount = 0;
    }
    
    
    //输入有符号大数
    struct UBigNumber InputUBN()
    {
        struct UBigNumber result;
        _InitUBN(&result);
    
        char ch;
        do
        {
            ch = getchar();
            if(ch == '-')
            {
                result.pHead->digit = '-';  //存储负号
                ch = getchar();
                break;
            }
            else
                result.pHead->digit = '+';  //存储正号
        }while(ch < '0' || ch > '9');
        while(ch >= '0' && ch <= '9')
        {
            _AppendDigit(&result, ch-'0');
            ch = getchar();
        }
        _Normalize(&result);
        return result;
    }
    
    
    //大数尾部添加1位数字
    void _AppendDigit(struct UBigNumber *pUBN, int digit)
    {
        if(pUBN->digitCount == 1 && pUBN->pTail->digit == 0)
        {
            pUBN->pTail->digit = digit;
            return;
        }
        struct Node *p = _NewNode();
        p->digit = digit;
        p->next = NULL;
        p->prev = pUBN->pTail;
        pUBN->pTail->next = p;
        pUBN->pTail = p;
        ++pUBN->digitCount;
    }
    
    
    //大数首部添加1位数字
    void _AppendFrontDigit(struct UBigNumber *pUBN, int digit)
    {
        struct Node *p = _NewNode();
        p->digit = digit;
        p->next = pUBN->pHead->next;
        if(p->next != NULL)
            p->next->prev = p;
        p->prev = pUBN->pHead;
        pUBN->pHead->next = p;
        if(pUBN->pTail == pUBN->pHead)
            pUBN->pTail = p;
        ++pUBN->digitCount;
    }
    
    
    //大数的规范表示,去除高位多余的0,至少含1位数字
    void _Normalize(struct UBigNumber *pUBN)
    {
        if(pUBN->digitCount == 0)
            _AppendDigit(pUBN, 0);
        while(pUBN->digitCount > 1 && pUBN->pHead->next->digit == 0)
        {
            struct Node *p;
            p = pUBN->pHead->next;
            pUBN->pHead->next = p->next;
            p->next->prev = pUBN->pHead;
            free(p);
            --pUBN->digitCount;
        }
    }
    
    
    //两个大数绝对值比较大小
    int  CmpUBN(struct UBigNumber *pA, struct UBigNumber *pB)
    {
        struct Node *p1, *p2;
        //先比较位数
        if(pA->digitCount > pB->digitCount)
            return 0;  //0标记pA大于等于pB
        else
        {
            p1 = pA->pHead->next;
            p2 = pB->pHead->next;
            while(p1 != NULL)  //位数相同,只需判断p1与p2其中一个即可
            {
                if(p1->digit < p2->digit)
                    return 1;//1标记pA小于pB
                p1 = p1->next;
                p2 = p2->next;
            }
        }
        return 0;  //pA与pB相等
    }
    
    
    //两个大数相加
    struct UBigNumber AddUBN(struct UBigNumber *pA, struct UBigNumber *pB)
    {
        struct UBigNumber result, *pResult = &result;
        _InitUBN(pResult);
        int iCarry = 0;
        struct Node *p1, *p2;
        p1 = pA->pTail;
        p2 = pB->pTail;
        while(p1 != pA->pHead && p2 != pB->pHead)
        {
            int digit = p1->digit + p2->digit + iCarry;
            iCarry = digit / 10;
            digit %= 10;
            _AppendFrontDigit(pResult, digit);
            p1 = p1->prev;
            p2 = p2->prev;
        }
        while(p1 != pA->pHead)
        {
            int digit = p1->digit + iCarry;
            iCarry = digit / 10;
            digit %= 10;
            _AppendFrontDigit(pResult, digit);
            p1 = p1->prev;
        }
        while(p2 != pB->pHead)
        {
            int digit = p2->digit + iCarry;
            iCarry = digit / 10;
            digit %= 10;
            _AppendFrontDigit(pResult, digit);
            p2 = p2->prev;
        }
        if(iCarry != 0)
            _AppendFrontDigit(pResult, iCarry);
        return result;
    }
    
    
    //两个大数相减
    struct UBigNumber SubUBN(struct UBigNumber *pA, struct UBigNumber *pB)
    {
        struct UBigNumber result, *pResult = &result;
        _InitUBN(pResult);
        int iCarry = 0;
        struct Node *p1, *p2;
        p1 = pA->pTail;
        p2 = pB->pTail;
        while(p1 != pA->pHead && p2 != pB->pHead)
        {
            int digit = p1->digit - p2->digit - iCarry;
            iCarry = 0;
            if(digit < 0)
            {
                digit += 10;
                iCarry = 1;
            }
            _AppendFrontDigit(pResult, digit);
            p1 = p1->prev;
            p2 = p2->prev;
        }
        while(p1 != pA->pHead)
        {
            int digit = p1->digit - iCarry;
            iCarry = 0;
            if(digit < 0)
            {
                digit += 10;  
                iCarry = 1;  //前一位退1
            }
            _AppendFrontDigit(pResult, digit);
            p1 = p1->prev;
        }
        _Normalize(pResult);
    
        return result;
    }
    
    
    //打印有符号大数
    void PrintUBN(struct UBigNumber ubn)
    {
        assert(ubn.digitCount > 0 && ubn.pHead->next != NULL);
        //若负数,打印负号
        if(ubn.pHead->digit == '-')
            printf("%c", ubn.pHead->digit);
        //打印数字
        struct Node *la = ubn.pHead->next;
        while(la)
        {
            printf("%d",la->digit);
            la = la->next;
        }
    }
    
    
    //销毁大数,释放空间
    void DestroyUBN(struct UBigNumber *pUBN)
    {
        while(pUBN->pHead != NULL)
        {
            struct Node *p = pUBN->pHead;
            pUBN->pHead = p->next;
            free(p);
        }
    }
    
    
    
    
    
    
    
    
    
    
    
    
    展开全文
  • 大数 加减乘 C++源代码 课程设计 上机实验 编程比赛 等可以使用
  • 大数加减运算

    2016-06-04 21:25:00
    这里自己利用STL模板中的容器和链表实现字符串大数加减运算. 1 #include<iostream> 2 #include<vector> 3 #include<list> 4 using namespace std; 5 6 list<char> Input_...
  • (加强版)大数加减乘除,一文彻底搞定

    多人点赞 热门讨论 2021-04-20 00:21:53
    前言大家好,我是bigsai!(上次发布的忘加原创并且今天的把内容扩充了一下)最近,大数加减频频登上笔试的舞台,小伙伴们在群里也分享自己遇到面试官碰到大数运算的题目,想着这么重要而简单的知...
  • 大数加减乘除?

    2017-12-18 16:46:36
    大数加减代码:(贴代码) //Bignumber.h#ifndef __BIGNUMBER_H #define __BIGNUMBER_h#include using namespace std;string bigadd(string s1, string s2); string bigsub(string s1, string s2); bool compareS1...
  • 大数加减乘法(Java)

    2017-07-25 09:38:35
    大数加减乘法(Java)
  • 航电1002大数加减问题

    2021-02-02 18:17:43
    一道基础大数加减问题,对两对字符串进行末位数加减,当然,末位数要进行数据类型转化,字符转化成数字,以此类推,注意进位即可。最后输出的时候再转化为对应的字符输出,数据位对10取模。需要注意的一点是,在前...
  • C#大数加减乘除取模

    千次阅读 2016-09-28 21:40:39
    using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks;namespace 大数加减乘除 { class Program { static void Main(string[] args)
  • * 两个大数加减发放,入参为字符串 * * @author 穹白 */ public class Solution { /** * 两数相加 */ public String add(String value1, String value2) { return deal(value1, value2, '+').reverse()....
  • 大数四则运算 大数四则运算(大数加减乘除,无限位数运算) 大数 数据结构 加减乘除 无限位数 运算
  • 大数除法算法 算法 大数加减乘除 高精度乘除法
  • 高精度 大数 加减乘除问题
  • 大数加减

    2021-01-20 12:11:32
    关于大数算法的一些*关于大数*思路大数加法大数减法大数乘法总结 能力有限,除法就不写了。。 关于大数 在C/C++语言编写过程中,数据并不是可以一直增长下去,数据极限大小由数据类型本身所占字节所决定,而一个字节...
  • 大数加减String类型完成大数的加减法 String类型 以后处理字符串可以直接用String类型 #include 编程能力强不强=处理字符串的能力强不强 C++中的string是一个标准库类型,表示可变长的字符序列,而由于是标准库类型...
  • 大数加减乘除

    2020-07-12 20:00:27
    【注意】所有位数完之后要注意还有没有进位。 void add(){ clen=0; memset(c,0,sizeof(c)); int x=0,temp; for(int i=0;i<len;i++){ temp=a[i]+b[i]+x; c[clen++]=temp%10; x=temp/10; } if(x){ c...
  • 模版--大数加减乘除

    2016-04-13 21:33:50
    /* 因为计算大数除法时需要用到乘法和减法, ...*//***********大数加减乘/仅限正整数***************/ //加法测试:HDU 1002 //减法测试:百练OJ 2736 //乘法测试:百练OJ 2980#include #include <cst
  • 模拟法计算大数加减乘除就是模拟列竖式的方法计算 大数加法 code: #include <stdio.h>//c 语言版 #include <string.h> #define maxn 10000500 char ans[maxn]; char *strrev(char *str){ char *p1, *p2...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,273
精华内容 509
关键字:

大数加减