设有2个10进制的n(n>10)位正整数,设计其适当的数据结构与算法,实现这2个数的加法

C语言大作业 题目是：请设计一个算法完成两个超长正整数的加法。谁会的帮帮忙？~

有没有具体的要求，比方说数据结构方面，我这有一个，你可以参考参考
#include"stdio.h"
#include"stdlib.h"
#define n 10 /*假定系统允许的最大作业为n，假定模拟实验中n值为10*/
#define m 10 /*假定系统允许的空闲区表最大为m，假定模拟实验中m值为10*/
#define minisize 100
struct{
float address; /*已分分区起始地址*/
float length; /*已分分区长度，单位为字节*/
int flag; /*已分配区表登记栏标志，用"0"表示空栏目*/
}used_table[n]; /*已分配区表*/

struct{
float address; /*空闲区起始地址*/
float length; /*空闲区长度，单位为字节*/
int flag; /*空闲区表登记栏标志，用"0"表示空栏目，用"1"表示未分配*/
}free_table[m]; /*空闲区表*/

void main( )
{
int i,a;
void allocate(char str,float leg);//分配主存空间函数
void reclaim(char str);//回收主存函数
float xk;
char J;/*空闲分区表初始化：*/
free_table[0].address=10240;
free_table[0].length=102400;
free_table[0].flag=1;
for(i=1;i<m;i++)
free_table[i].flag=0;/*已分配表初始化：*/
for(i=0;i<n;i++)
used_table[i].flag=0;
while(1)
{
printf("
选择功能项（0-退出,1-分配主存,2-回收主存,3-显示主存）
");
printf("选择功项(0~3) :");
scanf("%d",&a);
switch(a)
{
case 0: exit(0); /*a=0程序结束*/
case 1: /*a=1分配主存空间*/printf("输入作业名J和作业所需长度xk: ");
scanf("%*c%c%f",&J,&xk);
allocate(J,xk);/*分配主存空间*/
break;
case 2: /*a=2回收主存空间*/printf("输入要回收分区的作业名");
scanf("%*c%c",&J);reclaim(J);/*回收主存空间*/
break;
case 3: /*a=3显示主存情况*//*输出空闲区表和已分配表的内容*/
printf("输出空闲区表：
起始地址 分区长度 标志
");
for(i=0;i<m;i++)
printf("%6.0f%9.0f%6d
",free_table[i].address,free_table[i].length, free_table[i].flag);
printf(" 按任意键,输出已分配区表
");
getchar();
printf(" 输出已分配区表：
起始地址 分区长度 标志
");
for(i=0;i<n;i++)

if(used_table[i].flag!=0)
printf("%6.0f%9.0f%6c
",used_table[i].address,used_table[i].length, used_table[i].flag);
else
printf("%6.0f%9.0f%6d
",used_table[i].address,used_table[i].length, used_table[i].flag);
break;
default:printf("没有该选项
");
}/*case*/
}/*while*/
}/*主函数结束*/
int uflag;//分配表标志
int fflag;//空闲表标志
float uend_address;
float fend_address;
void allocate(char str,float leg)
{
uflag=0;fflag=0;
int k,i;float ressize;

for(i=0;i<m;i++)
{
if(free_table[i].flag==1 && free_table[i].length>=leg)
{
fflag=1;break;
}

}
if(fflag==0)
printf("没有满足条件的空闲区
");
else
{
ressize=free_table[i].length-leg;
for(k=0;k<n;k++)
{
if(used_table[k].flag==0)
{
if(ressize<minisize)//剩余块过小
{
used_table[k].length=free_table[i].length;
used_table[k].address=free_table[i].address;
used_table[k].flag=str;
free_table[i].length=0;
free_table[i].flag=0;
break;
}
else
{
used_table[k].address=free_table[i].address+ressize;
used_table[k].flag=str;
used_table[k].length=leg;
free_table[i].length=ressize;
break;
}
}
}//for结束
}
}
void reclaim(char str)
{
uflag=0;fflag=0;
int k,i;
for(k=0;k<n;k++)
{
if(used_table[k].flag==str)
{
uflag=1;break;
}
}
if(uflag==0)
printf("
找不到该作业!
");
else
{
for(i=0;i<m;i++)
{
uend_address=used_table[k].address+used_table[k].length;
fend_address=free_table[i].address+free_table[i].length;
if(used_table[k].address==fend_address)//上邻
{
fflag=1;
free_table[i].length=free_table[i].length+used_table[k].length;
free_table[i].flag=1;
used_table[k].flag=0;
used_table[k].length=0;
used_table[k].address=0;
printf("
已回收!
");
break;
}
else
{
if(free_table[i].address==uend_address)//下邻
{
fflag=1;
free_table[i].address=used_table[k].address;
free_table[i].length=free_table[i].length+used_table[k].length;
free_table[i].flag=1;
used_table[k].flag=0;
used_table[k].length=0;
used_table[k].address=0;
printf("
已回收!
");
break;
}
}
}//for结束
if(fflag==0)
{
i=0;
for(i=0;i<m;i++)
{
if(free_table[i].flag==0)
{
free_table[i].address=used_table[k].address;
free_table[i].length=used_table[k].length;
free_table[i].flag=1;
used_table[k].length=0;
used_table[k].flag=0;
used_table[k].address=0;
break;
}
}
printf("
已回收!
");
}
}
}

1.只考虑都是正数的情况，比较简单。 循环连别的节点这样定义： struct Node{ int data; Node * next; Node * pre}; 每个节点只保存小于10000的四位数，当两个长整数（也就是两个循环链表）相加的时候， 假设链表从低位到高位每四位保存到一个节点，那么就模拟加法的进位过程，两个链表的 对应节点相加，如果超过10000就向下一个节点进位，本节点只保留余数。 需要注意的是如果最后相加超过了最长链表的长度，加法的结果链表需要增加一个节点。 2.如果考虑加法的操作数有负数，设计要麻烦一些。 这个时候头结点要另外设计： struct SNode{ char symbol; Node * next; Node * pre;}; 中间节点同上。 如果两个都是负数，可以调用1中的方法相加，但是最后结果要取负数，也就是symbol='-'。 如果一正一负，可以重新设计一个减法借位的过程，不过还有一个更好的方法。 联想到计算机中对负数加法的操作，使用了取补相加的方法。 我们可以借鉴这种思想，取（两个数中最长位数+1）为模。将负数链表每个节点取反（每个节点的模为10000，等效于9999-原值）再加一，然后把两个链表用1中的进位方法相加，如果结果中最后一个节点产生了进位，那么结果为正数，除了头结点置正无需再加额外操作。如果结果中最后一个节点没有进位，那么结果是负数，需要将头节点symbol置于负，并将链表每位取反再加一。

pascal 高精度

高精度运算是指:当参与运算的数范围大大超出了标准数据类型（整型，实型）能表示的范围的运算时，通过数组、字串的形式，进行适当处理的方法。
&>16; 高精度加法
1、加数、减数、运算结果的输入和存储
用数组和字符串表示数据、结果。
（1）数组表示：每个数组元素存储1位，有多少位就需要多少个数组元素；（优化重点）
优点：每一位都是数的形式，可以直接加减；运算时非常方便
缺点：数组不能直接输入；输入时每两位数之间必须有分隔符，不符合数值的输入习惯；
（2）字符串表示：字符串的最大长度是255，可以表示255位。
优点：能直接输入输出，输入时，每两位数之间不必分隔符，符合数值的输入习惯；
缺点：每一位是一个字符，不能直接进行运算，必须先将它转化为数值再进行运算；
（3）综合以上所述，对两种数据结构取长补短：用字符串读入数据，用数组存储数据：
var s:string;{字符串最多可以表示255位}
a,b,c:array [1..260] of integer; {定义数组存放数字}
i,la,lb:integer;
begin
readln(s); {读入第一个字符串}
la:=length(s);{求出s的长度，也即第一个数的位数； }
for i:=1 to la do {将字符串的每一位字符转化为数字,并倒序存入数组a}
a[i]:=ord(s[la-i+1])-ord(‘0’)
readln(s);
lb:=length(s);{求出s的长度，也即第二个数的位数； }
for i:=1 downto lb do
a[i]:=ord(s[lb-i+1])-ord(‘0’)
end;
2、运算过程：模拟手工计算
（1）运算顺序：从低位向高位运算；先计算低位再计算高位；
（2）运算规则：同一位的两个数相加再加上从低位来的进位，成为该位的和；这个和去掉向高位的进位就成为该位的值；如上例：3+8+1=12，向前一位进1，本位的值是2；可借助MOD、DIV运算完成这一步；
（3）最后一位的进位：如果完成两个数的相加后，进位位值不为0，则应添加一位；
（4）如果两个加数位数不一样多，则按位数多的一个进行计算；
if la>=lb then len:=la else len:=lb;
y:=0 {y表示进位,初值为0}
for i:=1 to len do do
begin
x:=a[i]+b[i]+y; c[i]:=x mod 10; y:=x div 10;
// c[i]:=a[i]+b[i]+c[i];c[i+1]:=c[i] div 10; c[i]:=c[i] mod 10
end;
if y<>0 then len:=len+1;
//if c[len+1]>0 then len:=len+1;
3、结果的输出（优化重点）:按运算结果的实际位数输出
for i:=len downto 1 do write(c[i]);

完整程序:高精度加法
program bigPlus;
var
a,b,c: array[1..260] of integer;
la,lb,len,i:integer;
s:string;

procedure init;
begin
fillchar(a,sizeof(a),0);
fillchar(b,sizeof(b),0);

fillchar(c,sizeof(c),0);
readln(s);
la:=length(s);
for i:=1 to la do a[la-i+1]:=ord(s[i])-ord('0');
readln(s);
lb:=length(s);
for i:=1 to lb do b[lb-i+1]:=ord(s[i])-ord('0');
if la>=lb then len:=la else len:=lb;
end;
begin
init; {调用初始化过程}
for i:=1 to len do
begin
c[i]:=a[i]+b[i]+c[i];
c[i+1]:=c[i] div 10;
c[i]:=c[i] mod 10;
end;
if c[len+1]<>0 then len:=len+1;
for i:=len downto 1 do write(c[i]);
readln;
end.
4、优化：
以上的方法的有明显的缺点：
（1）浪费空间：一个整型变量（-32768~32767）只存放一位（0~9）；
（2）浪费时间：一次加减只处理一位；
针对以上问题，我们做如下优化：一个数组元素存放四位数；（integer的最大范围是32767，5位的话可能导致出界）。具体方法：
a.初始化过程要改变:
procedure init;
begin
fillchar(a,sizeof(a),0);
fillchar(b,sizeof(b),0);
fillchar(c,sizeof(c),0);
readln(s);
la:=length(s)
for i:=1 to la do
begin
j:=(la-i)div 4+1;
a[j]:=a[j]*10+ord(s[i])-48;
end;
readln(s);
lb:=length(s);
for i:=1 to lb do
begin
j:=(lb-i)div 4 +1;
b[j]:=b[j]*10+ord(s[i])-48;
end;
la:=(la+3) div 4;
lb:=(lb+3) div 4;
if la>=lb then len:=la else len:=lb;
end;
b.运算过程要改变 mod 10000 div 10000
c.输出要改变:
if c[len+1]>0 then len:=len+1;
write(c[len]);
for i:=len-1 downto 1 do
begin
if c[i]<1000 then write(‘0’) ;
if c[i]<100 then write(‘0’);
if c[i]<10 then write(‘0’);
write(c[i]);
end;

算法要相应改变：
（1）运算时：不再逢十进位，而是逢万进位（mod 10000; div 10000);
（2）输出时：最高位直接输出，其余各位，要判断是否足够4位，不足部分要补0；例如：1，23，2345这样三段的数，输出时，应该是100232345而不是1234567。

&>16; 高精度减法
1、和高精度加法相比，减法在差为负数时处理的细节更多一点：当被减数小于减数时，差为负数，差的绝对值是减数减去被减数；在程序实现上用一个变量来存储符号位，用另一个数组存差的绝对值。
2、算法流程：
（1）读入两个字符串S1，S2（字符串）；
（2）置符号位：判断被减数是否大于减数：大则将符号位置为空；小则将符号位置为“-”，交换减数与被减数；
（3）被减数与减数处理成数值，放在数组中；

（4）运算：
A、取数；
B、判断是否需要借位；
C、减，将运算结果放到差数组相应位中；
D、判断是否运算完成：是，转5；不是，转A；
（5）打印结果：符号位，第1位，循环处理第2到最后一位；

3、细化：
（1）如何判断被减数与减数的大小：
{首先将两个字符串的位数补成一样(因为字符串的比较是从左边对齐的；两个字符串一样长才能真正地比较出大小)：短的在左边补0}
la:=length(s1);
lb:=length(s2);
if la>lb then for i:=1 to la-lb do s2:='0'+s2
else for i:=1 to lb-la do s1:='0'+s1;
{接着比较大小：直接比较字符串大小，s1存被减数，fh存符号}
fh:='';
if s1<s2 then begin fh:='-';s:=s1; s1:=s2; s2:=s; end;
（2）将字符串处理成数值：
la:=length(s1);{求出s1的长度，也即s1的位数。}
for i:=l to la do
a[la-i+1]:=ord(s1[i])-48; {将字符转成数值并倒序放入数组a}
字符串s2的处理方法同上
（3）打印结果：去掉结果中多余的0

完整程序:高精度减法 (未优化,优化方法参照加法的优化)
program bigminus;
var
a,b,c: array[1..260] of integer;
la,lb,len,i:integer;
s1,s2:string;

procedure init;
begin
fillchar(a,sizeof(a),0);
fillchar(b,sizeof(b),0);
readln(s1);
readln(s2);
la:=length(s1);
lb:=length(s2);
if la>lb then for i:=1 to la-lb do s2:='0'+s2
else for i:=1 to lb-la do s1:='0'+s1;
if s1<s2 then begin s:=s1; s1:=s2; s2:=s; write('-');end;
if la>=lb then len:=la else len:=lb;
for i:=1 to len do a[len-i+1]:=ord(s[i])-ord('0');
for i:=1 to len do b[len-i+1]:=ord(s[i])-ord('0');
end;
begin
init; {调用初始化过程}
for i:=1 to len do
begin
c[i]:=a[i]-b[i]+c[i];
if c[i]<0 then
begin c[i]:=c[i]+10;c[i+1]:=c[i+1]-1;end;
end;
while (len>1)and(c[len]=0) then len:=len-1; {调整长度,输出时去掉多余的0}
for i:=len downto 1 do write(c[i]);
readln;
end.
高精度乘法:
(1) 高精度乘以低精度
(2) 高精度乘以高精度
高精度运算的过程汇总:
高精度数的定义：
type
hp=array[1..maxlen] of integer;
1．高精度加法
procedure plus ( a,b:hp; var c:hp);
var i,len:integer;
begin
fillchar(c,sizeof(c),0);
if a[0]>b[0] then len:=a[0] else len:=b[0];
for i:=1 to len do begin
inc(c[i],a[i]+b[i]);
if c[i]>10 then begin dec(c[i],10); inc(c[i+1]); end; {进位}
end;
if c[len+1]>0 then inc(len);
c[0]:=len;
end;{plus}

2．高精度减法
procedure substract(a,b:hp;var c:hp);
var i,len:integer;
begin
fillchar(c,sizeof(c),0);
if a[0]>b[0] then len:=a[0] else len:=b[0];
for i:=1 to len do begin
inc(c[i],a[i]-b[i]);
if c[i]<0 then begin inc(c[i],10);dec(c[i+1]); end;
while (len>1) and (c[len]=0) do dec(len);
c[0]:=len;
end;

3．高精度乘以低精度
procedure multiply(a:hp;b:longint;var c:hp);
var i,len:integer;
begin
fillchar(c,sizeof(c),0);
len:=a[0];
for i:=1 to len do begin
inc(c[i],a[i]*b);
inc(c[i+1],(a[i]*b) div 10);
c[i]:=c[i] mod 10;
end;
inc(len);
while (c[len]>=10) do begin {处理最高位的进位}
c[len+1]:=c[len] div 10;
c[len]:=c[len] mod 10;
inc(len);
end;
while (len>1) and (c[len]=0) do dec(len); {若不需进位则调整 len}
c[0]:=len;
end;{multiply}

4．高精度乘以高精度
procedure high_multiply(a,b:hp; var c:hp}
var i,j,len:integer;
begin
fillchar(c,sizeof(c),0);
for i:=1 to a[0] do
for j:=1 to b[0] do begin
inc(c[i+j-1],a[i]*b[j]);
inc(c[i+j],c[i+j-1] div 10);
c[i+j-1]:=c[i+j-1] mod 10;
end;
len:=a[0]+b[0]+1;
while (len>1) and (c[len]=0) do dec(len);
c[0]:=len;
end;

5．高精度除以低精度
procedure devide(a:hp;b:longint; var c:hp; var d:longint);
{c:=a div b; d:= a mod b}
var i,len:integer;
begin
fillchar(c,sizeof(c),0);
len:=a[0]; d:=0;
for i:=len downto 1 do begin
d:=d*10+a[i];
c[i]:=d div b;
d:=d mod b;
end;
while (len>1) and (c[len]=0) then dec(len);
c[0]:=len;
end;

6．高精度除以高精度
procedure high_devide(a,b:hp; var c,d:hp);
var
i,len:integer;
begin
fillchar(c,sizeof(c),0);
fillchar(d,sizeof(d),0);
len:=a[0];d[0]:=1;
for i:=len downto 1 do begin
multiply(d,10,d);
d[1]:=a[i];
while(compare(d,b)>=0) do {即 d>=b}
begin
Subtract(d,b,d);
inc(c[i]);
end;
end;
while(len>1)and(c.s[len]=0) do dec(len);
c.len:=len;
end;

---

新巴尔虎右旗18748263011： 设有2个10进制的n(n>10)位正整数,设计其适当的数据结构与算法,实现这2个数的加法 - ？
表路依路： pascal 高精度高精度运算是指:当参与运算的数范围大大超出了标准数据类型(整型,实型)能表示的范围的运算时,通过数组、字串的形...

新巴尔虎右旗18748263011： 计算机利用的是二进制,它共有两个数码0、1,将一个十进制数转化成二进制数,只要把该数写成若干个2n - ？
表路依路： #include <stdio.h> void main() { int a; scanf(\＂%d\＂,&a);//输入一个10进制数. int result=0;//存储a的二进制结果. int p=1;//p=1表示个位数 do { int b=a%2;//b是余数,第一个余数是二进制的个位. result=result+p*b; p=p*10;//*10表示下个是10...

新巴尔虎右旗18748263011： C语言编程题 计算2个非常大的十进制整数(可正可负)之和 - ？
表路依路： #include int main() { char inputA[80 + 1]; char inputB[80 + 1]; char result[81 + 1]; memset(result, 0, sizeof(result)); char* pSrc; char* pResult; char* pInputA = inputA; char* pInputB = inputB; int sizeResult = 0; int sizeSrc = 0; int numA = 0; int numB = 0; ...

新巴尔虎右旗18748263011： K进制下的加法 c语言 - ？
表路依路： 这问题实际上是在于如何将十进制的数显示为k进制数.#include void Show(int n, int k) { int m[16],i,nn; char c; for ( i=0;i i=0; nn=n; do { m[i++]=nn%k; nn/=k; } while ( nn ); for ( ;i>0;i-- ) { c=m[i-1]; c+=( c printf(＂%c＂,c); } } void main() { int k,x,y,z; ...

新巴尔虎右旗18748263011： C语言!!!编写三个函数,根据输入的一个十进制的数,分别输出对应 - ？
表路依路： # include<stdio.h>//函数声明 void B(int n);//二进制 void Q(int n);//八进制 void H(int n);//十六进制 int main(void) { int n; printf(＂请输入十进制数n:\n＂); scanf(＂%d＂,&n); B(n); printf(＂\n＂); Q(n); printf(＂\n＂); H(n); return 0; } void B(int n) ...

新巴尔虎右旗18748263011： 题目:输入二个十进制数(0 - 255). - ？
表路依路： var m,n:0..255; i,j,k:integer; a:array[1..1000]of 0..1; procedure shuzhizhuanhuan(p:0..255,var a:array[1..1000]of 0..1,var o:integer;); var i:integer; begin repeat inc(i); a[i]:=p mod 2; p:=p div 2; until p=0; o:=i; end; begin write('n,m='); readln(n,m); if n>m ...

新巴尔虎右旗18748263011： VC程序编写结束,怎么把最后输出的数字由10进制转化为2进制?？
表路依路： 给定一个十进制正整数n,正整数n转换成二进制 迭代算法: for(n;n&gt;0;n/=2) { b[i]=n%2; i++; } for(i;i&gt;=0;i--) { cout&lt;&lt;b[i]; } 以上为在C++中经调试验证的程序段.

新巴尔虎右旗18748263011： 输入两个十进制数,求和,并输出 汇编 - ？
表路依路： #inclue(stdio.h) main() { float a,b,c; scanf(＂%f,%f＂,&a,&b); c=a+b; printf(＂%f\n＂,c); }

新巴尔虎右旗18748263011： c语言编写一程序,以字符串形式输入两个十进制数,将两个字符串对应的十进制数相加,将得到的结果输出.？
表路依路： #include&lt;stdio.h&gt; #include&lt;string.h&gt; #include&lt;math.h&gt; main() { char str1[200],str2[200]; int i,n1,n2; long a=0,b=0; gets(str1); gets(str2); n1=strlen(str1); n2=strlen(str2); for(i=0;i&lt;n1;i++) a=a+((str1[i]-48)*pow(10,n1-i-1)); printf(＂a=%ld...

新巴尔虎右旗18748263011： 编写一个程序,将十进制整数n 转换成二进制数.本人初学C++,求指导？
表路依路： 你这是c语言,不是c++. #include&lt;stdio.h&gt; int main() { int a, b, n, i; int temp[10]; printf(＂请输入一个整数:＂); scanf(＂%d＂,&amp;a); //n=1; //printf(＂%d＂,n); n = 0; while(a&gt;0){ b = a % 2; a = a / 2; temp[n++] = b; } for(i=n-1; i&gt;=0; i--) printf(＂%d＂, temp[i]); } 你要想下10进制转成2进制,是从最低位求起的,也就是求余的结果要反过来, 你拿笔自己算算看.