长整数加法运算
问题描述
假设2个任意长度的整数x、y分别用链表A和B存储，现要求设计一个算法，实现x+y。计算结果存储在链表C中。
说明：
链表A、B、C可以是单向链表或双向链表，但由于A和B输出时需要从头至尾遍历，而做加法时需要从尾至头遍历，因此推荐使用双向链表存储。
链表的每个结点的数据域可以选择以下三种设计方式：
（1）链表的每个结点存储长整数的一位（不推荐）；
（2）链表的每个结点从长整数的低位开始拆分（4位为一组，存到一个结点中，即结点的数据域为不超过9999的非负整数），依次存放在链表的每个结点；
（3）链表的每个结点从长整数的低位开始拆分（4位为一组，存到一个结点中，即结点的数据域为1-4位字符串），依次存放在链表的每个结点。
可利用头结点的数据域存放正负数标志（正数或0：1(“1”)，负数：-1(“-1”)）。
输入说明
第一行：长整数x
第二行：长整数y
输出说明
第一行：格式化后的长整数x（从低位到高位每4位用","分开）
第二行：格式化后的长整数y（从低位到高位每4位用","分开）
第三行：空行
第四行：格式化后的计算结果（从低位到高位每4位用","分开）
（输入与输出之间用一空行分隔）
输入范例
-53456467576846547658679870988098
435643754856985679
输出范例
-5345,6467,5768,4654,7658,6798,7098,8098
43,5643,7548,5698,5679
-5345,6467,5768,4611,2014,9250,1400,2419
题解
思路
- 输出
43,5643,7548,5698,5679样式用string拼接实现。 - 在计算中，关键是如何判断最终结果的负号，或者说A，B到底哪一个绝对值更大，这将决定异号时谁减谁。
我的做法：
A、B逆序模拟加减法计算，结果头插到新链表
分步完成计算，第一步，A、B每个结点分别添置符号先不考虑进位，暴力相加（减法转为加负数，允许结果绝对值超过 1w）
根据结果头部4位数去决定符号【头部的数字最大，如何借位进位都不可能改变正负】，
--,++,+-,-+四种情况统一了，第二步如下两条：在同号相加计算中，考虑进位溢出，更要考虑头部4位是否溢出（>=10000）
在异号相加【减法】计算中，考虑与头部符号异号的那组数的符号纠正，考虑向前借位。
- 在输出中，关键是如何判断，是否需要添有效0，比如：
1,0000，避免无效0的出现，比如：0001，000,0000,0000。
代码实现
#include<iostream>
#include<cstring>
#include<stack>
#include<iomanip>
using namespace std;
const int W =10000;
typedef struct node
{
int data;
struct node *next;
struct node* pre;
} link;
int main()
{
string a,b;
cin>>a>>b;
// 预处理，补齐符号位，便于开头逗号处理。 比如正好四位数 会遇到 “，1234”开头添置逗号的情况。
if(a[0] != '-')a ="+"+a;
if(b[0] != '-')b ="+"+b;
string new_a="",new_b="";
int ct =0;
for(int i=a.length()-1; i>=0; i--)
{
if(a[i] >='0' && a[i]<= '9')
{
new_a =to_string(a[i])+new_a;
ct++;
if(ct == 4)
{
new_a =","+new_a;
ct =0;
}
}
else // meet + 、-
{
if(new_a[0] ==',')new_a.erase(0,1);
if(a[i] == '-')new_a =to_string(a[i])+new_a;
}
}
cout<<new_a<<endl;
ct=0;
for(int i=b.length()-1; i>=0; i--)
{
if(b[i] >='0' && b[i]<= '9')
{
new_b =to_string(b[i]) + new_b;
ct++;
if(ct == 4)
{
new_b ="," +new_b;
ct =0;
}
}
else
{
if(new_b[0] ==',')new_b.erase(0,1);//去掉开头误加上的逗号。
if(b[i] == '-')new_b =to_string(b[i])+new_b;//符号位打印只需要负号
}
}
cout<<new_b<<endl;
cout<<endl;
//
link* A,*B;
A = new link;
B = new link;
create_dob_link(A,new_a);
create_dob_link(B,new_b);
// calculate A + B
link *C = new link;
C->next = NULL;
C->pre = NULL;
calculate(A,B,C);
print_link(C);
}
创建双向链表函数
void create_dob_link(link *head,string data)
{
link *tail =head;
tail->next = NULL;
tail->pre = NULL;
//judge + -
if(data[0] == '-')
{
head->data =-1;
data.erase(0,1);
}
else head->data = 1;
//additional ','
data +=",";
//
int res=0;
for(int i=0; i<data.length(); i++)
{
if(data[i] >='0' && data[i]<='9')//condition： number
{
res =res*10 + data[i]-'0';
}
else //condition：,
{
link * p = new link;
p->data = res;
p->next = tail->next;
tail->next = p;
p->pre =tail;
tail = p;
//initial
res =0;
}
}
}
char to string 函数（挺笨的，但有效）
string只能拼接字符串，无法拼接字符。
string to_string(char x)
{
string res;
if(x == '0')res="0";
else if(x == '1')res="1";
else if(x == '2')res="2";
else if(x == '3')res="3";
else if(x == '4')res="4";
else if(x == '5')res="5";
else if(x == '6')res="6";
else if(x == '7')res="7";
else if(x == '8')res="8";
else if(x == '9')res="9";
else if(x == '-')res="-";
return res;
}
头插法构建结果链表
void head_insert_link(link *C,int data)
{
link * p = new link;
p->data = data;
p->next = C->next;
C->next = p;
p->pre = C;
if(p->next)p->next ->pre = p;
}
结果打印函数（※）
void print_link(link *head)
{
int f=false;//判断是否遇到了有效数字
int ff =false;//判断当前的0是否为有效数字
link *p=head->next;
if(head->data < 0)cout<<"-";
while(p)
{
if(p->data != 0)
{
//print
if(ff)cout<<setfill('0')<<setw(4)<<abs(p->data);
else cout<<abs(p->data);//condition: 1,0001 需要补有效0
f =true;
}
else //condition: 1,0000,0000 需要补有效0
{
if(f ==true && p->data == 0)cout<<"0000";
}
//
if(f && p->next)
{
cout<<",";
//只要有逗号，0左侧一定会有数，后面遇到的数就是需要有效0。
ff =true;
}
p=p->next;
}
//condition： 000,0000 纯零结果
if(f == false)cout<<"0";
cout<<endl;
}
长整数加减计算函数（※※※）
void calculate(link * A, link * B,link * C)
{
// part 1:先不考虑进位
link *pa=A->next, * pb=B->next;
while(pa->next)pa = pa->next;
while(pb->next)pb = pb->next;
while(pa !=A && pb != B)
{
//with +- maybe out range
int res = pa->data * A->data + pb->data * B->data;
head_insert_link(C,res);
//next
pa=pa->pre;
pb=pb->pre;
}
while(pa != A)
{
int res = pa->data * A->data ;
head_insert_link(C,res);
pa=pa->pre;
}
while(pb != B)
{
int res = pb->data * B->data;
head_insert_link(C,res);
pb=pb->pre;
}
//part 2:
//由顶部四位决定最终取值正负
link * p =C->next;
while(p->next)p=p->next;
if(p && p->data < 0)C->data =-1;
else C->data =1;
while(p->pre != C)
{
//消除异号
if(p->data * C->data < 0)
{
if(p->data <0)
{
p->data +=W;
p->pre->data -=1;//头部为正值，借位，前面少了个1
}
else if(p->data >0)
{
p->data -=W;
p->pre->data+=1;//头部为负值，借位，前面少了个-1， 对负数来说+1就是少了。
}
// else 0000 pass.
}
//同号进位,（未考虑头部溢出），while(p->pre != C) 就决定了 p是处理不到头部4位就结束了。下面补上了这个溢出处理。
if(abs(p->data)>= W )
{
if(p->data > 0)
{
p->data -=W;
p->pre->data +=1;
}
else
{
p->data +=W;
p->pre->data +=-1;
}
}
p=p->pre;
}
if(abs(p->data)>=W)//补充，考虑头部溢出
{
p->data %=W;
head_insert_link(C,1);
}
}
