无限长整数运算

最新推荐文章于 2021-11-27 16:12:33 发布
最新推荐文章于 2021-11-27 16:12:33 发布
阅读量1.5k 收藏 3
点赞数 1
文章标签： null delete string c struct c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/futou2004/article/details/421994
版权

#include<iostream>
#include<string>
using namespace std;
//************************************  定义结构  *************************************
struct node             
{int data;node*next;};
//************************************  show1  ****************************************
void show1(node*head,int i)                 //将链表反向输出
{cout<<"将以上两整数相加后结果是:/n";
node*a,*b;int t,k,j,w;
a=head;b=head->next;
if(b==NULL)goto l;              //如果结果只有一位,则链表不反向,直接goto
for(k=1;1;k++)                  //以下十多行是链表反向的代码
{t=a->data;
a->data=b->data;
b->data=t;
a=b;
b=b->next;
if(b==NULL)break;}
for(;k!=1;k--){a=head;b=head->next;
for(j=1;j<=k-1;j++)
{t=a->data;
a->data=b->data;
b->data=t;
a=b;
b=b->next;}}
l:if(i)cout<<'-';        
w=1;              
a=head;                      //以下是按整数输出的表示习惯,每三位一组,间用逗号分隔
while(a)
{a=a->next;
w++;}                        //w-1是结果的位数
switch((w-1)%3)
{case 1:cout<<head->data;if(head->next!=NULL)cout<<',';head=head->next;w=1;while(head)
   {cout<<head->data;
        if(w%3==0&&head->next!=NULL)cout<<',';
          head=head->next;w++;}break;
 case 2:cout<<head->data;head=head->next;cout<<head->data;if(head->next!=NULL)cout<<',';head=head->next;
  w=1;while(head)
   {cout<<head->data;
        if(w%3==0&&head->next!=NULL)cout<<',';
          head=head->next;w++;}break;
 default:w=1;while(head)
   {cout<<head->data;
        if(w%3==0&&head->next!=NULL)cout<<',';
          head=head->next;w++;}}cout<<endl;
cout<<"********************************************************************"<<endl;
cout<<"版本：2005.2.19"<<endl;
cout<<"Copyright(c) 2005 C2 704 C++Development Team"<<endl;
cout<<"all rights reserved.未经授权不得复制."<<endl;
cout<<"********************************************************************"<<endl;}

//************************************  加法函数c1  ************************************
void c1(node*head,node*head1,int u)    
{int i=0;node*head2=NULL,*t=new node,*e;
while(1)
{
if((head->data+head1->data+i)>=10)      //第一种情况:同一位上的两数相加大于十,
{t->data=i+head->data+head1->data-10;   //满十进一,i就是向上一位进一的"1"
 if(head2==NULL)head2=t;
    else e->next=t;
    e=t;
 t=new node;
 i=0;i++;
 head=head->next;
 head1=head1->next;
if(head==NULL&&head1==NULL)        //head与head1两整数位数一样多
{t->data=1;e->next=t;e=t;e->next=NULL;break;}
else if(head!=NULL&&head1==NULL)   //head链表的整数比head1的位数多   
{while(1+head->data==10&&head!=NULL)
{t->data=1+head->data-10;
e->next=t;e=t;
t=new node;
head=head->next;
if(head==NULL)break;}
if(head==NULL){
t->data=1;
e->next=t;
e=t;
e->next=NULL;break;}
else {t->data=1+head->data;
e->next=t;e=t;e->next=head->next;break;}
}
else if(head1!=NULL&&head==NULL)  //head1链表的整数比head的位数多
{while(1+head1->data==10&&head1!=NULL)
{t->data=1+head1->data-10;
e->next=t;e=t;
t=new node;
head1=head1->next;
if(head1==NULL)break;}
if(head1==NULL){
t->data=1;
e->next=t;
e=t;
e->next=NULL;break;}
else {t->data=1+head1->data;
e->next=t;e=t;e->next=head1->next;break;}}}
else                          //另一种情况:同一位上的两数相加小于等于十
{   t->data=i+head->data+head1->data;
    i=0;
 if(head2==NULL)head2=t;
    else e->next=t;
    e=t;
    t=new node;
    head=head->next;
 head1=head1->next;
if(head==NULL&&head1==NULL){delete t;e->next=NULL;break;}  //head与head1两整数位数一样多
else if(head!=NULL&&head1==NULL){delete t;e->next=head;break;}//head链表的整数比head1的位数多
else if(head1!=NULL&&head==NULL){delete t;e->next=head1;break;}//head1链表的整数比head的位数多
}}show1(head2,u);}      
//*********************************** 符号互异位数不同的两整数加法函数c2 *********************************
void c2(node*head,node*head1,int u)     //head存放绝对值位数较多的整数
{int i=0;node*head2=NULL,*t=new node,*e;
while(head1!=NULL)
{if(i+head->data-head1->data<0)  //正整数与负整数的加法运算转换成两个正整数的减法运算    
{t->data=i+head->data+10-head1->data;
if(head2==NULL)head2=t;
    else e->next=t;
    e=t;
 t=new node;
 i=0;i--;
 head=head->next;
 head1=head1->next;
while(head!=NULL&&head1==NULL)//因为head存放绝对值位数较多的整数，所以head1比head先指向NULL
{ if(i+head->data>0) {t->data=i+head->data;e->next=t;
                      e=t;e->next=head->next;break;}
else if(i+head->data<0){ t->data=i+head->data+10;e->next=t;e=t;
                        t=new node;i=0;i--;head=head->next;}
else if(i+head->data==0){t->data=0;
if(head->next==NULL){delete t;e->next=NULL;e=head2;
while(1&&e->next!=NULL)
{if(e->next->data==0&&e->next->next==NULL)
{   e->next=NULL;e=head2;if(e->next==NULL)break;continue;}
if(e->next->data!=0&&e->next->next==NULL)break;
e=e->next;}              
break;}
          e->next=t;e=t;e->next=head->next;break;}}
}
else {t->data=head->data-head1->data+i;
i=0;
if(head2==NULL)head2=t;
    else e->next=t;
    e=t;
    t=new node;
    head=head->next;
 head1=head1->next;
if(head!=NULL&&head1==NULL){delete t;e->next=head;break;}//head的位数长于head1
}}show1(head2,u);}
//***********************************  符号互异位数相同的两整数加法函数c3  **********************************
void c3(node*head,node*head1,int u)      //绝对值位数较多的放在head链表
{int i=0;node*head2=NULL,*t=new node,*e;
while(1)
{if(i+head->data-head1->data<0)//正整数与负整数的加法运算转换成两个正整数的减法运算
{t->data=i+head->data+10-head1->data;
 if(head2==NULL)head2=t;
    else e->next=t;
    e=t;
 t=new node;
 i=0;i--;              //i是不够减时向高位借一的那个"1"
 head=head->next;
 head1=head1->next;}
else {t->data=head->data-head1->data+i;  
     i=0;
    if(head2==NULL)head2=t;
    else e->next=t;
    e=t;
    t=new node;
    head=head->next;
 head1=head1->next;
 if(head==NULL&&head1==NULL){delete t;e->next=head;
 e=head2;
 while(1&&e->next!=NULL)
{if(e->next->data==0&&e->next->next==NULL)
{   e->next=NULL;e=head2;if(e->next==NULL)break;continue;}
if(e->next->data!=0&&e->next->next==NULL)break;
e=e->next;} 
 break;}}}
show1(head2,u);
}
//###########################*********  主函数main  ***********###############################
int main()
{string a,b,h;node*head,*head1,*s,*p,*q;   s=new node;int k,d,s1,t1,u,m=0;
cout<<"请输入一个整数(带逗号):" ;
cin>>a;                       //输入的长整数以字符串形式存于string变量a，b中
cout<<"请输入另一个整数(带逗号):";
cin>>b;
//****************  输入的是两个负整数  ***********************
if(a[0]==45&&b[0]==45)        //判断整数符号
{for(k=0;a[k]!=NULL;k++);     //此行是计算长整数位数,存于k中     
s->data=a[k-1]-48;   //以下是把字符串反向存于一条链表中,每一结点存一个字符串元素(以整数形式)
head=NULL;
while(1)
{if(head==NULL)head=s;
else p->next=s;
p=s;
if(k-2<=0)break;    //加了等号,即不把负号存入链表中
s=new node;         //也即表示不带符号进行运算
k--;
if(a[k-1]==44)k--;                  
s->data=a[k-1]-48;}
p->next=NULL;
for(k=0;b[k]!=NULL;k++);
s=new node;
s->data=b[k-1]-48;
head1=NULL;
while(1)
{if(head1==NULL)head1=s;
else q->next=s;
q=s;
if(k-2<=0)break;      //加了等号,即不把负号存入链表中
s=new node;           //也即表示不带符号进行运算
k--;
if(b[k-1]==44)k--;       //不把逗号存入链表中
s->data=b[k-1]-48;}
q->next=NULL;
t1=1;        //t1是输送给c1函数的,用来判断符号
c1(head,head1,t1); }
//*****************************  输入的是两符号互异(包括零和负数)  *****************************
else if(a[0]==45&&b[0]>=48||b[0]==45&&a[0]>=48)   //两符号互异(包括零和负数)
{  for(k=0;a[k]!=NULL;k++);                     //四个for语句来计算a与b除符号外的位数
   for(d=0;b[d]!=NULL;d++);
   for(s1=0;a[k-1]!=NULL&&a[k-1]!=45;s1++,k--);
   for(t1=0;b[d-1]!=NULL&&b[d-1]!=45;t1++,d--);
    k=s1;d=t1;
if(k>d&&a[0]==45&&b[0]>=48)                      //先输入a是负且绝对值大，后输入b是正，得出结果是负号
{g: for(k=0;a[k]!=NULL;k++);
 for(d=0;b[d]!=NULL;d++);
 s->data=a[k-1]-48;
   head=NULL;
   while(1)
   {if(head==NULL)head=s;
   else p->next=s;
   p=s;
   if(k-2<=0)break;          //加了等号,即不把负号存入链表中         
   s=new node;               //也即表示不带符号进行运算
   k--;
   if(a[k-1]==44)k--;       
   s->data=a[k-1]-48;}
   p->next=NULL;
 s=new node;
   s->data=b[d-1]-48;
   head1=NULL;
   while(1)
   {if(head1==NULL)head1=s;
   else q->next=s;  
   q=s;
   if(d-2<0)break;          //由于b字符串不带负号,所以不加等号
   s=new node; 
   d--;
   if(b[d-1]==44)d--;        
   s->data=b[d-1]-48;}
   q->next=NULL;
   u=1;                           //用u来判断结果的符号
   c2(head,head1,u);}  //因head位数多于head1,故head放在head1的左边
else if(k<d&&a[0]==45&&b[0]>48)        //先输入a是负且绝对值小，后输入b是正，得出结果是正号
{ l: for(k=0;a[k]!=NULL;k++);          
  for(d=0;b[d]!=NULL;d++);
  s->data=a[k-1]-48;
   head=NULL;
   while(1)
   {if(head==NULL)head=s;
   else p->next=s;
   p=s;
   if(k-2<=0)break;           
   s=new node;
   k--;
   if(a[k-1]==44)k--;        
   s->data=a[k-1]-48;}
   p->next=NULL;
 s=new node;
   s->data=b[d-1]-48;
   head1=NULL;
   while(1)
   {if(head1==NULL)head1=s;
   else q->next=s;
   q=s;
   if(d-2<0)break;           
   s=new node;
   d--;
   if(b[d-1]==44)d--;        
   s->data=b[d-1]-48;}
   q->next=NULL;
   u=0;                                         //因已知结果为正,故赋值给u,使函数得以识别结果符号
   c2(head1,head,u);}                           //因head1位数多于head,故head1放在head的左边
else if(k>d&&b[0]==45&&a[0]>48){h=a;a=b;b=h;goto l;}//先输入a是正且绝对值大，后输入b是负，得出结果是正号
else if(k<d&&b[0]==45&&a[0]>=48){h=a;a=b;b=h;goto g;}//先输入a是正且绝对值小，后输入b是负，得出结果是负号      
else if(k==d)                    //输入的是符号互异位数相同的两整数
{j:  for(k=0;a[k]!=NULL;k++);
     for(d=0;b[d]!=NULL;d++);
 if(k!=s1)                     //a为负数
{ for(k=1,d=0;a[k]!=NULL&&b[d]!=NULL;k++,d++)
 {   if(a[k]>b[d])             //a是负数，而且绝对值a大于b
 {for(k=0;a[k]!=NULL;k++);
 for(d=0;b[d]!=NULL;d++);
 s->data=a[k-1]-48;
   head=NULL;
   while(1)
   {if(head==NULL)head=s;
   else p->next=s;
   p=s;
   if(k-2<=0)break;          //加了等号,即不把负号存入链表中         
   s=new node;               //也即表示不带符号进行运算
   k--;
   if(a[k-1]==44)k--;        
   s->data=a[k-1]-48;}
   p->next=NULL;
 s=new node;
   s->data=b[d-1]-48;
   head1=NULL;
   while(1)
   {if(head1==NULL)head1=s;
   else q->next=s;
   q=s;
   if(d-2<0)break;           
   s=new node;
   d--;
   if(b[d-1]==44)d--;        
   s->data=b[d-1]-48;}
   q->next=NULL;
   u=1;m=0;
   c3(head,head1,u);   //head存放绝对值大的数,所以head放在head1的左边  
 break;}                       
else if(a[k]<b[d])                 //a是负数，但绝对值b大于a
 {for(k=0;a[k]!=NULL;k++);
 for(d=0;b[d]!=NULL;d++);
 s->data=a[k-1]-48;
   head=NULL;
   while(1)
   {if(head==NULL)head=s;
   else p->next=s;
   p=s;
   if(k-2<=0)break;          //加了等号,即不把负号存入链表中          
   s=new node;               //也即表示不带符号进行运算
   k--;
   if(a[k-1]==44)k--;        
   s->data=a[k-1]-48;}
   p->next=NULL;
 s=new node;
   s->data=b[d-1]-48;
   head1=NULL;
   while(1)
   {if(head1==NULL)head1=s;
   else q->next=s;
   q=s;
   if(d-2<0)break;           
   s=new node;
   d--;
   if(b[d-1]==44)d--;        
   s->data=b[d-1]-48;}
   q->next=NULL;
   u=0;m=0;
  c3(head1,head,u);        //head1存绝对值放大的数,所以head1放在head的左边
  break;}
else if(a[k]==b[d])       //相反数相加得零,转换成判断除符号外得字符是否完全相同,
{m=1;continue;}}          //若相同,则赋值给m,令cout语句执行
if(m){cout<<"将以上两整数相加后结果是:/n";
     cout<<0<<endl;}}
 else if(d!=t1)              //b为负数
 {h=a;a=b;b=h;goto j;}}}     //变成a存放放负数,利用goto语句,避免打重复的代码
//***********************************  输入的是两个正整数  ************************************
else
{for(k=0;a[k]!=NULL;k++);
s->data=a[k-1]-48;
head=NULL;
while(1)
{if(head==NULL)head=s;
else p->next=s;
p=s;
if(k-2<0)break;  //k-2<0若改为"<="则这部分与上面的"输入的是两个负整数"源程序完全相同
s=new node;
k--;
if(a[k-1]==44)k--;       
s->data=a[k-1]-48;}
p->next=NULL;
for(k=0;b[k]!=NULL;k++);
s=new node;
s->data=b[k-1]-48;
head1=NULL;
while(1)
{if(head1==NULL)head1=s;
else q->next=s;
q=s;
if(k-2<0)break;  //k-2<0若改为"<="则这部分与上面的"输入的是两个负整数"源程序完全相同
s=new node;
k--;
if(b[k-1]==44)k--;       
s->data=b[k-1]-48;}
q->next=NULL;
s1=0;
c1(head,head1,s1);}return 0;}

futou2004
关注
长整数的运算
06-19
【问题描述】<br>实现任意多位的两个大整数的加、减、乘运算。<br>【输入形式】<br>用文件“算式.txt”（与编译后的程序在同一目录下）输入两个十进制大整数A和B。<br>在文件“算式.txt”中依次分行输入以下内容：<br>1. 第一行输入第一个大整数A。A前带正负号，后面是任意多位的数字序列。<br>2. 第二行只有一个字符，可以是“+”、“-”、“*”，分别代表加、减、乘三种运算符。<br>3. 第三行输入大整数B，格式与A相同。<br>注：<br>1. A、B均不带有前缀的多余的0。<br>2. B的末尾也要有换行符（回车）。<br>【输出形式】<br>用文件“结果.txt” （与编译后的程序在同一目录下）输出运算结果。<br>在文件“结果.txt”中打印运算结果，输出一行字符序列，是大整数A和B和运算结果。<br>首先要输出正负号。各位数字紧密输出，不带有前缀的多余的0。<br>【样例输入】<br>+5465655454489465198465<br>+<br>-42454465164656552465<br>【样例输出】<br>+5423200989324808646000
长整数运算
Chief_Yan的博客
10-12 2474
Python长整数运算正整数相加对位相加整数相减 正整数相加 这次，我们加法采用对位相加，也就是两个长整数对应位上的数字相加，之后再计算进位，最后得出结果的方法。 对位相加 例如 数字 加数 1111 被加数 99999 先将数字串分割为独立的数字,再对位相加。 ··· 十万 万位 千位 百位 十位 个位 加数 0 0 1 1 1 1 + + + + + + + 被加数 0 9 9 9 9 9 结果 0 9 10 10 10 10 之后是处理进位。
长整数的基本操作
caozuiba
07-18 257
//LongInt.cpp:Definestheentrypointfortheconsoleapplication.//#include"stdafx.h"#include"string.h"#defineMAXLEN50/**//*functionInputLongInt()长整数输入函数*/intInputLongInt(int*a,char*para)...{intlen,i;cha...
javascript-biginteger：基于字符串的无限长度整数运算
02-13
这个库允许开发者在JavaScript环境中执行基于字符串的大整数运算，支持加法、减法、乘法、除法以及模运算等。 javascript-biginteger库的核心思想是使用字符串来表示大整数，因为JavaScript字符串可以容纳任意长度...
高精度计算器（无限长整数运算）
03-10
在IT领域，高精度计算器是一种能够处理非常大或者非常精确数值的计算工具，它能进行无限长整数运算，甚至包括小数运算。这类计算器在处理金融、科学计算或者密码学等领域时尤其有用，因为这些场景往往需要超越普通...
C语言专业课程设计报告长整数四则运算.doc
07-12
程设计报告——长整型数四则运算 ...总结，本课程设计通过C语言实现了一个灵活且适应性强的长整数四则运算程序，充分利用了链表数据结构的优势，满足了对任意长度长整数运算的需求，并提供了良好的用户交互体验。
哈夫曼码的编译码系统;递归替换问题;跳马问题;长整数运算问题;数据结构课程设计课程设计.pdf
07-14
本课程设计涉及四个主要主题：哈夫曼编码、递归替换问题、跳马问题和长整数运算，这些都是在实际编程和算法设计中经常遇到的问题。 一、哈夫曼码的编/译码系统 哈夫曼编码是一种有效的前缀编码方法，用于无损数据...
两无限长整数相加的C++源代码
05-27
总结来说，"两无限长整数相加"的C++实现涉及到的主要知识点包括：动态数组的使用、大整数表示、位级别的加法运算、进位处理以及面向对象编程中的类设计和运算符重载。理解和掌握这些概念对于提升C++编程能力，尤其是...
长整数加减运算
01-03
可以实现特别长的整数之间的加减法运算，其中长整数可以达到几十兆的大小。主要是运用数据结构中的链表实现功能。
长整数运算.zip
10-31
[ 问题描述 ] 设计程序实现两个任意长整数的求和运算。 [ 基本要求 ] 《数据结构》题集 利用双向循环链表实现长整数的存储, 每个结点含一个整型变量. 任何整型变量的范围是 －(215－1)～(215－1)。输入和输出形式: 按中国对于长整数的表示习惯, 每四位一组，组间用逗号隔开。 [ 测试数据 ] (1) 0;0;应输出"0"。 (2) -2345,6789;-7654,3211; 应输出"-1,0000,0000"。 (3) -9999,9999; 1,0000,0000,0000; 应输出"9999,0000,0001"。 (4) 1,0001,0001; -1,0001,0001; 应输出"0"。 (5) 1,0001,0001; -1,0001,0000; 应输出"1"。 [ 实现提示 ] (1) 每个结点可以存放的最大整数为 215-1 = 32767 才能保证两数相加不会溢出。但若这样存，即相当于按 32768 进制数存，在十进制数与 32768 进制数间的转换十分不方便，故可以在每个结点中仅存十进制数的 4 位，即不超过 9999的非负整数, 整个链表被视为万进制。 (2)可以利用头结点数据域的符号代表长整数的符号。 用其绝对值表示元素结点数目。相加过程中不要破坏两个操作数链表。两操作数的头指针存于指针数组中是简化程序结构的一种方法。不能给长整数位数规定上限。 [ 选作内容 ] 修改上述程序，使它在整型量范围是－(2n－1)～(2n－1) 的计算机上都能有效地运行。其中 n 是由程序读入的参量。输入数据的分组方法可另行规定。
长整数计算器
11-03
长整数计算器，可以进行加减乘除取余等运算，还可以进行自增自减
综合计算器5.0——可进行无限大整数的乘方运算
03-01
可进行实数、复数、一元多项式、长整数（即位数在理论上可无限大的整数）运算的计算器。 界面简单易用，非常容易上手。
长整数四则运算 C语言
04-25
首先对输入串进行输入格式判断，如果判断不正确则重新输入，输入正确将输入串存储在链表中 。根据链表的存储结果和相应算法对链表进行相应的操作。判断输入串是整数还是负数决定是否输出‘-’，对两串的绝对值的大小进行比较，并根据四则运算控制符的符号来判断进行的运算和符号标识位的值。
长整数加法运算
sdaujsj1的博客
10-27 906
https://blog.csdn.net/Yeluorag/article/details/50300507
长整数代数运算
InterestAndFun的博客
03-27 2818
1.1、 设计任务与目标 1.1、1. 任务描述 长整数代数运算： 应用线性数据结构解决长整数的计算问题。设计数据结构完成长整数的表示和存储，并编写算法来实现两长整数的加、减、乘、除等基本代数运算。 1.1、2. 具体目标 (1) 长整数长度在一百位以上。 (2) 实现两长整数的加、减、乘、除操作。 (3) 输入输出均在文件中。 (4) 分析算法的时空复杂性。 1.1、3. 目的意义 在一般的程序运算中，长整数是无法计算的，因为计算机一次能够运算的位数是有限，一旦整数很长，就需要一个程序来进行多次计算，通过
长整数加减法运算
CHN_Zgq's Blog
11-27 2730
长整数加减法运算 【问题描述】 设计一个实现任意长的整数进行加法和减法运算的演示程序。 【基本要求】 利用双向循环链表实现长整数的存储，每个结点含一个整型变量。输入和输出形式：按中国对于长整数的表示习惯，每四位一组，组间用逗号隔开。 【测试数据】 (1)0；0；应输出“0”。 (2)-2345,6789；-7654,3211；应输出“-1,0000,0000”。 (3)-9999,9999；1,0000,0000,0000；应输出“9999,0000,0001” (4)1,0001,0001；-1,0001
大整数的代数运算代码
最新发布
06-29
大整数的代数运算通常涉及到高效的算法和数据结构，因为直接使用常规整数类型在处理大数值时会遇到溢出的问题。以下是一个简单的Python示例，使用内置的`int`类型和`math`模块进行基本的大整数乘法（辗转相乘法）： ```python import math def multiply_large_numbers(num1, num2): # 将输入转换为字符串，以便于无限长的乘法操作 str_num1 = str(num1) str_num2 = str(num2) # 初始化结果为0 result = 0 # 遍历第一个数的每一位 for digit1 in str_num1: # 乘以第二个数的每个位，加到结果上 result = (result + int(digit1) * int(math.pow(10, len(str_num2) - 1))) % 10 ** len(str_num2) # 移动第二个数的指针 num2 = num2 * 10 return result # 示例 num1 = 999999999999999999 num2 = 987654321098765432 print(multiply_large_numbers(num1, num2))
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值