作者:不详 来源:互联网 酷勤网收集 2008-04-25
请设计一个算法来完成两个超长正整数的加法。
*问题分析与算法设计
首先要设计一种数据结构来表示一个超长的正整数,然后才能够设计算法。
首先我们采用一个带有表头结点的环形链来表示一个非负的超大整数,如果从低位开始为每 个数字编号,则第一位到第四位、第五位到第八位...的每四位组成的数字,依次放在链表的第一个、第二个、...结点中,不足4位的最高位存放在链表的最后一个结点中,表头结点的值规定为-1。例如:
大整数“587890987654321”可用如下的带表头结点head的链表表示:
按照此数据结构,可以从两个表头结点开始,顺序依次对应相加,求出所需要的进位后代入下面的运算。具体的实现算法请见程序中的注释。
*程序说明与注释
#include<stdio.h>
#include<stdlib.h>
#define HUNTHOU 10000
typedef struct node{ int data;
struct node *next;
}NODE; /*定义链表结构*/
NODE *insert_after(NODE *u,int num); /*在u结点后插入一个新的NODE,其值为num*/
NODE *addint(NODE *p,NODE *q); /*完成加法操作返回指向*p+*q结果的指针*/
void printint(NODE *s);
NODE *inputint(void);
int main()
{
NODE *s1,*s2,*s;
NODE *inputint(), *addint(), *insert_after();
printf("Enter S1= ");
s1=inputint(); /*输入被加数*/
printf("Enter S2= ");
s2=inputint(); /*输入加数*/
printf(" S1="); printint(s1); putchar('/n'); /*显示被加数*/
printf(" S2="); printint(s2); putchar('/n'); /*显示加数*/
s=addint(s1,s2); /*求和*/
printf("S1+S2="); printint(s); putchar('/n'); /*输出结果*/
}
NODE *insert_after(NODE *u,int num)
{
NODE *v;
v=(NODE *)malloc(sizeof(NODE)); /*申请一个NODE*/
v->data=num; /*赋值*/
u->next=v; /*在u结点后插入一个NODE*/
return v;
}
NODE *addint(NODE *p,NODE *q) /*完成加法操作返回指向*p+*q结果的指针*/
{
NODE *pp,*qq,*r,*s,*t;
int total,number,carry;
pp=p->next; qq=q->next;
s=(NODE *)malloc(sizeof(NODE)); /*建立存放和的链表表头*/
s->data=-1;
t=s; carry=0; /*carry:进位*/
while(pp->data!=-1&&qq->data!=-1) /*均不是表头*/
{
total=pp->data+qq->data+carry; /*对应位与前次的进位求和*/
number=total%HUNTHOU; /*求出存入链中部分的数值 */
carry=total/HUNTHOU; /*算出进位*/
t=insert_after(t,number); /*将部分和存入s向的链中*/
pp=pp->next; /*分别取后面的加数*/
qq=qq->next;
}
r=(pp->data!=-1)?pp:qq; /*取尚未自理完毕的链指针*/
while(r->data!=-1) /*处理加数中较大的数*/
{
total=r->data+carry; /*与进位相加*/
number=total%HUNTHOU; /*求出存入链中部分的数值*/
carry=total/HUNTHOU; /*算出进位*/
t=insert_after(t,number); /*将部分和存入s指向的链中*/
r=r->next; /*取后面的值*/
}
if(carry) t=insert_after(t,1); /*处理最后一次进位*/
t->next=s; /*完成和的链表*/
return s; /*返回指向和的结构指针*/
}
NODE *inputint(void) /*输入超长正整数*/
{
NODE *s,*ps,*qs;
struct number {int num;
struct number *np;
}*p,*q;
int i,j,k;
long sum;
char c;
p=NULL; /*指向输入的整数,链道为整数的最低的个位,链尾为整数的最高位*/
while((c=getchar())!='/n') /*输入整数,按字符接收数字*/
if(c>='0'&&c<='9') /*若为数字则存入*/
{
q=(struct number *)malloc(sizeof(struct number)); /*申请空间*/
q->num=c-'0'; /*存入一位整数*/
q->np=p; /*建立指针*/
p=q;
}
s=(NODE *)malloc(sizeof(NODE));
s->data=-1; /*建立表求超长正整数的链头*/
ps=s;
while(p!=NULL) /*将接收的临时数据链中的数据转换为所要求的标准形式*/
{
sum=0;i=0;k=1;
while(i<4&&p!=NULL) /*取出低四位*/
{
sum=sum+k*(p->num);
i++; p=p->np; k=k*10;
}
qs=(NODE *)malloc(sizeof(NODE)); /*申请空间*/
qs->data=sum; /*赋值,建立链表*/
ps->next=qs;
ps=qs;
}
ps->next=s;
return s;
}
void printint(NODE *s)
{
if(s->next->data!=-1) /*若不是表头,则输出*/
{
printint(s->next); /*递归输出*/
if(s->next->next->data==-1)
printf("%d",s->next->data);
else{
int i,k=HUNTHOU;
for(i=1;i<=4;i++,k/=10)
putchar('0'+s->next->data%(k)/(k/10));
}
}
}
*运行结果
*思考题
请设计完成两个超长正整数的减法、乘法和除法的运算。
作者:不详 来源:互联网 酷勤网收集 2008-04-25
在图中的九个点上,空出中间的点,其余的点上任意填入数字1到8;1的位置固定不动,然后移动其余的数字,使1到8顺时针从小到大排列.移动的规律是:只能将数字沿线移向空白的点.
请编程显示数字移动过程。
*问题分析与算法设计
分析题目中的条件,要求利用中间的空白格将数字顺时针方向排列,且排列过程中只能借空白的点来移动数字.问题的实质就是将矩阵外面的8个格看成一个环,8个数字在环内进行排序,同于受题目要求的限制"只能将数字沿线移向空白的点",所以要利用中间的空格进行排序,这样要求的排序算法与众不同.
观察中间的点,它是唯一一个与其它8个点有连线的点,即它是中心点.中心点的活动的空间最大,它可以向8个方向移动,充分利用中心点这个特性是算法设计成功与否的关键.
在找到1所在的位置后,其余各个数字的正确位置就是固定的.我们可以按照下列算法从数字2开始,一个一个地来调整各个数字的位置.
*确定数字i应处的位置;
*从数字i应处的位置开始,向后查找数字i现在的位置;
*若数字i现在位置不正确,则将数字i从现在的位置(沿连线)移向中间的空格,而将原有位置空出;依次将现有空格前的所有元素向后移动;直到将i应处的位置空出,把它移入再次空出中间的格.
从数字2开始使用以上过程,就可以完成全部数字的移动排序.
编程时要将矩阵的外边八个格看成一个环,且环的首元素是不定的,如果算法设计得不好,程序中就要花很多精力来处理环中元素的前后顺序问题.将题目中的3X3矩阵用一个一维数组表示,中间的元素(第四号)刚好为空格,设计另一个指针数组,专门记录指针外八个格构成环时的连接关系.指针数组的每个元素依次记录环中数字在原来数组中对应的元素下标.这样通过指针数组将原来矩阵中复杂的环型关系表示成了简单的线性关系,从而大大地简化了程序设计.
*程序说明与注释
#include<stdio.h>
int a[]={0,1,2,5,8,7,6,3}; /*指针数组.依次存入矩阵中构成环的元素下标*/
int b[9]; /*表示3X3矩阵,b[4]为空格*/
int c[9]; /*确定1所在的位置后,对环进行调整的指针数组*/
int count=0; /*数字移动步数计数器*/
int main()
{
int i,j,k,t;
void print();
printf("Please enter original order of digits 1~8:");
for(i=0;i<8;i++)
scanf("%d",&b[a[i>);
/*顺序输入矩阵外边的8个数字,矩阵元素的顺序由指针数组的元素a[i]控制*/
printf("The sorting process is as felow:/n");
print();
for(t=-1,j=0;j<8&&t==-1;j++) /*确定数字1所在的位置*/
if(b[a[j>==1) t=j; /*t:记录数字1所在的位置*/
for(j=0;j<8;j++) /*调整环的指针数组,将数字1所在的位置定为环的首*/
c[j]=a[(j+t)%8];
for(i=2;i<9;i++) /*从2开始依次调整数字的位置*/
/*i:正在处理的数字,i对应在环中应当的正确位置就是i-1*/
for(j=i-1;j<8;j++) /*从i应处的正确位置开始顺序查找*/
if(b[c[j>==i&&j!=i-1) /*若i不在正确的位置*/
{
b[4]=i; /*将i移到中心的空格中*/
b[c[j>=0;print(); /*空出i原来所在的位置,输出*/
for(k=j;k!=i-1;k--) /*将空格以前到i的正确位置之间的数字依次向后移动一格*/
{
b[c[k>=b[c[k-1>; /*数字向后移动*/
b[c[k-1>=0;
print();
}
b[c[k>=i; /*将中间的数字i移入正确的位置*/
b[4]=0; /*空出中间的空格*/
print();
break;
}
else if(b[c[j>==i) break; /*数字i在正确的位置*/
}
void print(void) /*按格式要求输出矩阵*/
{
int c;
for(c=0;c<9;c++)
if(c%3==2) printf("%2d ",b[c]);
else printf("%2d",b[c]);
printf("----%2d----/n",count++);
}
*运行结果
*问题的进一步讨论
很显然,按照上述算法都能解决问题,但移动的步数并不是最少的。
注意算法中的两个问题。其一:数字1的位置自始自终是保持不变的;其2:没有考虑到初始情况下,位置原本就已经是正确的数字。如例中的数字5和6,按照算法,当移动其它数字时,5和6了要跟着移动多次,这显然费了不少步数。
对于实例,若让数字1参与其它数字的移动排序过程,并充分利用数字5和6初始位置已经正确这一条件,可以大大优化移动排序的过程。
*思考题
请重新设计算法,编写更优化的程序,尽可能减少移动的步数。