• #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);
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);
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 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;
}


展开全文
• 大数加减优化一、大数加减的代码大数相加大数相减二、大数加减编程题AcWing 791. 高精度加法AcWing 792. 高精度减法 一、大数加减的代码 大数相加 vector<int> add(vector<int> &A, vector<int&...
大数加减优化一、大数加减的代码大数相加大数相减二、大数加减编程题AcWing 791. 高精度加法AcWing 792. 高精度减法

一、大数加减的代码
大数相加
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;

{
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');
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++实现大数加减乘，绝对可以实现。希望分享
• java 数组实现大数加减乘除运算 下载 算法思想很简单，都是我自己做的，相信肯花时间每个人都可以写出来更好的。
• ## 整数的大数加减

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

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

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

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

判断运算类型

输出符号判断

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

输出运算结果  找到第一个不为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

{
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("-");
}
else
}
}
if(sign=='-')
{
if(flag1*flag2==1)
{
sub(min(range-len1,range-len2),flag1);       //正-正 负-负
}
if(flag1*flag2==-1)
{
}
}
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;  //位数
};

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个结点，返回结点指针
//当分配失败时，简化程序，退出运行
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;  //设置结点数值
if(p->next != NULL)
p->next->prev = p;
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;
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;
{
int digit = p1->digit + p2->digit + iCarry;
iCarry = digit / 10;  //新进位
digit %= 10;  //当前结果位
_AppendFrontDigit(pResult, digit);  //添加至结果最高位
p1 = p1->prev;  //准备处理前一位
p2 = p2->prev;
}
{
int digit = p1->digit + iCarry;
iCarry = digit / 10;
digit %= 10;
_AppendFrontDigit(pResult, digit);
p1 = p1->prev;
}
{
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;
{
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;
}
{
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)
{
{
struct Node *p = pUBN->pHead;  //待删除结点
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;  //位数
};

//动态分配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();
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;  //设置结点数值
if(p->next != NULL)
p->next->prev = p;
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;
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;
{
int digit = p1->digit + p2->digit + iCarry;
iCarry = digit / 10;  //新进位
digit %= 10;  //当前结果位
_AppendFrontDigit(pResult, digit);  //添加至结果最高位
p1 = p1->prev;  //准备处理前一位
p2 = p2->prev;
}
{
int digit = p1->digit + iCarry;
iCarry = digit / 10;
digit %= 10;
_AppendFrontDigit(pResult, digit);
p1 = p1->prev;
}
{
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;
{
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;
}
{
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)
{
{
struct Node *p = pUBN->pHead;  //待删除结点
free(p);  //释放结点
}
}


处理有符号大数加减

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

//输入有符号大数
struct UBigNumber InputUBN();
//大数绝对值比较大小
int  CmpUBN(struct UBigNumber *pA, struct UBigNumber *pB);
//打印有符号大数
void PrintUBN(struct UBigNumber ubn);

函数的实现

//输入有符号大数
struct UBigNumber InputUBN()
{
struct UBigNumber result;
_InitUBN(&result);

char ch;
do
{
ch = getchar();
if(ch == '-')
{
ch = getchar();
break;
}
else
}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
{
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);
//若负数，打印负号
//打印数字
while(la)
{
printf("%d",la->digit);
la = la->next;
}
}


完整代码

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <malloc.h>

struct Node
{
int digit;  //数字
struct Node *next, *prev;  //前后指针
};

struct UBigNumber
{
int digitCount;  //位数
};

//动态分配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(CmpUBN(&A, &B))
{   //A绝对值比B绝对值小
D = SubUBN(&B, &A);
}
else
{
D = SubUBN(&A, &B);
}

}
//输入第一个正数，第二个负数
{
if(CmpUBN(&A, &B))
{   //A绝对值比B绝对值小
C = SubUBN(&B, &A);
}
else
{
C = SubUBN(&A, &B);
}
}
//输入第一个负数，第二个正数
{
if(CmpUBN(&A, &B))
{   //A绝对值比B绝对值小
C = SubUBN(&B, &A);
}
else
{
C = SubUBN(&A, &B);
}
}
//输入第一个负数，第二个负数
{
if(CmpUBN(&A, &B))
{   //A绝对值比B绝对值小
D = SubUBN(&B, &A);
}
else
{
D = SubUBN(&A, &B);
}
}

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();
p->next = p->prev = NULL;
pUBN->digitCount = 0;
}

//输入有符号大数
struct UBigNumber InputUBN()
{
struct UBigNumber result;
_InitUBN(&result);

char ch;
do
{
ch = getchar();
if(ch == '-')
{
ch = getchar();
break;
}
else
}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;
if(p->next != NULL)
p->next->prev = p;
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;
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
{
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;
{
int digit = p1->digit + p2->digit + iCarry;
iCarry = digit / 10;
digit %= 10;
_AppendFrontDigit(pResult, digit);
p1 = p1->prev;
p2 = p2->prev;
}
{
int digit = p1->digit + iCarry;
iCarry = digit / 10;
digit %= 10;
_AppendFrontDigit(pResult, digit);
p1 = p1->prev;
}
{
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;
{
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;
}
{
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);
//若负数，打印负号
//打印数字
while(la)
{
printf("%d",la->digit);
la = la->next;
}
}

//销毁大数，释放空间
void DestroyUBN(struct UBigNumber *pUBN)
{
{
free(p);
}
}




展开全文
• 大数 加减乘 C++源代码 课程设计 上机实验 编程比赛 等可以使用
• 这里自己利用STL模板中的容器和链表实现字符串大数加减运算. 1 #include<iostream> 2 #include<vector> 3 #include<list> 4 using namespace std; 5 6 list<char> Input_...
• 前言大家好，我是bigsai！(上次发布的忘加原创并且今天的把内容扩充了一下)最近，大数加减频频登上笔试的舞台，小伙伴们在群里也分享自己遇到面试官碰到大数运算的题目，想着这么重要而简单的知...
• 大数加减代码：（贴代码） //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)
• 一道基础大数加减问题，对两对字符串进行末位数加减，当然，末位数要进行数据类型转化，字符转化成数字，以此类推，注意进位即可。最后输出的时候再转化为对应的字符输出，数据位对10取模。需要注意的一点是，在前...
• 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()....
• 大数四则运算 大数四则运算（大数加减乘除，无限位数运算） 大数 数据结构 加减乘除 无限位数 运算
• 大数除法算法 算法 大数加减乘除 高精度乘除法
• 高精度 大数 加减乘除问题
• 关于大数算法的一些*关于大数*思路大数加法大数减法大数乘法总结 能力有限，除法就不写了。。 关于大数 在C/C++语言编写过程中，数据并不是可以一直增长下去，数据极限大小由数据类型本身所占字节所决定，而一个字节...
• 大数加减String类型完成大数的加减法 String类型 以后处理字符串可以直接用String类型 #include 编程能力强不强=处理字符串的能力强不强 C++中的string是一个标准库类型，表示可变长的字符序列，而由于是标准库类型...
• 【注意】所有位数完之后要注意还有没有进位。 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...
• /* 因为计算大数除法时需要用到乘法和减法， ...*//***********大数加减乘/仅限正整数***************/ //加法测试：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...

...