大整数的乘法－列表法

  大整数的乘法

 

       在计算机中，长整形（long int）变量的范围是-2147483648至2147483647，因此若用长整形变量做乘法运算，乘积最多不能超过10位数。即便用双精度（double）变量，也仅能保证16位有效数字的精度。在某些需要更高精度的乘法运算场合，需要用别的办法来实现运算。

      比较容易想到的是做多位数乘法时列竖式进行计算的方法，只要写出模拟这一过程的程序，就能实现任意大整数的乘法运算。经过查阅资料，找到一种更易于编程的方法，即“列表法”。

 

下面先介绍“列表法”:

例如当计算8765*234时，把乘数和被乘数照如下列出，见表1：

 

8	7	6	5	*
16	14	12	10	2
24	21	18	15	3
32	28	24	20	4

 

                           表一

 

 

 

16	14	12	10
	24	21	18	15
		32	28	24	20
16	38	65	56	39	20

 

   

	16	38	65	56	39	20
2	16+4=20	38+7=45	65+6=71	56+4=60	39+2=41
留2	留0进2	留5进4	留1进7	留0进6	留1进4	留0进2
2	0	5	1	0	1	0

 

  根据以上思路 就可以编写C程序了，再经分析可得：

1，一个m位的整数与一个n位的整数相乘，乘积为m+n-1位或m+n位。

2，程序中，用三个字符数组分别存储乘数，被乘数与乘积。由第1点分析知，存放乘积的字符数组饿长度应不小于存放乘数与被乘数的两个数组的长度之和。

3，可以把第二步“计算填表”与第三四步“累加进位”放在一起完成，可以节省存储表格2所需的空间。

4，程序关键部分是两层循环，内层循环累计一数组的和，外层循环处理保留的数字和进位。

[cpp] view plain copy

1. #define MAXLENGTH 1000  
2. #include <stdio.h>  
3. #include <string.h>  
4.   
5. void compute(char * a, char * b,char *c)  
6. {  
7.   int i,j,m,n;  
8.   long sum,carry;  
9.   m = strlen(a)-1;  
10.   n = strlen(b)-1;  
11.  for(i=m;i>=0;i--)  
12.     a[i] -= '0';  
13.  for(i=n;i >=0;i--)  
14.     b[i] -='0';  
15.   c[m+n+2] ='/0';  
16.  carry =0;  
17.  for(i=m+n;i>=0;i--)  
18.  {  
19.    sum=carry;  
20.    if((j=(i-m))<0)  
21.      j=0;  
22.    for(;j<=i&& j <=n;j++)  
23.        sum += a[i-j]b[j];  
24.    c[i+1] = sum %10 + '0'; /*算出保留的数字*/  
25.    carry = sum/10;  
26.  }  
27.  if((c[0]=carry+'0')=='0') /* if no carry*/  
28.    c[0] = '/040'; /* space */  
29. }  
30.   
31. int main()  
32. {  
33.    char a[MAXLENGTH],b[MAXLENGTH],c[MAXLENGTH*2];  
34.    puts("Input multiplier");  
35.    gets(a);  
36.    puts("Input multiplier");  
37.    gets(b);  
38.    compute(a,b,c);  
39.    puts("Answer:");  
40.    puts(c);  
41.    getchar();  
42. }  

效率分析：用以上算法计算m位整数乘以n位整数，需要先进行m*n次乘法，再进行约m+n次加法运算和m+n次取模运算（实为整数除法）。把这个程序稍加修改，让它自己生产乘数和被乘数，然后计算机随机的7200为整数互乘。

   经过改进，此算法效率可以提高约9倍。

    注意到以下事实：8216547*96785 将两数从个位起，每3位分为节，列出乘法表，将斜线间的数字相加：

    8  216  547

         96   785

8	216	547	*
768	20736	52512	96
6250	169560	429395	785

 

768	20736	52512
	6250	169560	429395
768	27016	222072	429395

 

 

 

将表中最后一行进行如下处理：从个位数开始，每一个方格里只保留三个数字，超出1000的部分进位到前一个方格里：

  

	768	27016	222072	429395
	768+27=795	27016+222=27238	222072+429=222501	留395进429
	795	238	501	395

所以8216547*96785 = 795238501395

 

 也就是说我们在计算生成这个二维表时，不必一位一位的乘，而可以三位三位的乘；在累加时也是满1000进位。这样，我们计算m位整数乘以n位整数，只需要进行m*n/9次乘法运算，再进行约（m+n）/3次加法运算和（m+n）/3次去摸运算。总体看来，效率是前一种算法的9倍。

  有人可能会想：既然能用三位三位的乘，为什么不能4位4位的乘，甚至5位。听我解来：本算法在累加表中斜线间的数字时，如果用无符号长整数（范围0至~4294967295）作为累加变量，在最不利的情况下（两个乘数的所有数字均为9），能够累加约4294967295/（999*999）=4300次，也就是能够准确计算任意两个约不超过12900（每次累加的结果“值”三位，故4300*3=12900）位的整数相乘。如果4位4位地乘，在最不利的情况下，能过累加月4294967295/(9999*9999)=43次，仅能够确保任意两个不超过172位的整数相乘，没什么实用价值，更不要说5位了。

 

 

[cpp] view plain copy

1. #include <stdio.h>  
2. #include <string.h>  
3. #include <conio.h>  
4. #include <stdlib.h>  
5. #include <time.h>  
6. #define N 7200 //做72xx位的整数乘法  
7. int max(int a,int b,int c)  
8. {  
9.   int d = (a >b)?a:b;  
10.   return (d>c)?d:c;  
11. }  
12. int initarray(int a[])  
13. {  
14.    int q,p,i;  
15.    q = N + random(100);  
16.    if(q%3 ==0)  
17.       p =q/3;  
18.    else  
19.       p =q/3+1;  
20.    for(i=0;i <p;i++)  
21.       a[i] = random(1000);  
22.    if(q%3 ==0)  
23.         a[0] = 100+random(900);  
24.    if(q%3 == 2)  
25.        a[0] = 10 + random(90);  
26.    if(q%3 == 1)  
27.        a[0] = 1 + random(9);  
28.    return p;   
29. }  
30. void write(int a[],int l)  
31. {  
32.    int i;  
33.    char string[10];  
34.    for(i=1;i<l;i++)  
35.    {  
36.      itoa(a[i],string,10);  
37.      if(strlen(string)==1)  
38.        fprintf(fp,"00");  
39.      if(strlen(string)==2)  
40.        fprintf(fp,"0");  
41.      fprintf(fp,"%s",string);  
42.      if((i+1)%25 == 0)  
43.         fprintf(fp,"/n");  
44.    }  
45.    fprintf(fp,"/n");  
46.    fprintf(fp,"/n");  
47. }  
48. FILE * fp;  
49.   
50. int main()  
51. {  
52.    int a[5000]={0},b[5000]={0},k[10001]={0};  
53.    unsigned long c,d,e;//申明作累加用的无符号长整数变量  
54.    int i,j,la,lb,ma,mi,p,q,t;  
55.    randomize();//初始化随机数  
56.      
57.   la = initarray(a);//被乘数  
58.   lb = initarray(b);//乘数  
59.     
60.   if(la < lb)//如果被乘数长度小于乘数，则交换被乘数与乘数  
61.   {  
62.     p = (lb > la)?lb:la;  
63.     for(q=0;q<p;q++)  
64.      t=a[q],a[q]=b[q],b[q]=t;  
65.     t =la,la=lb,lb =t;  
66.   }   
67.   c=d=0;  
68.   for(i=la+lb-2;i>=0;i--)//累加斜线间的数，i位横纵坐标之和  
69.   {  
70.     c=d;//将前一位的进位标志存入累加变量C  
71.     ma =max(0,i-la+1,i-lb+1);//求累加的下限  
72.      mi = (i > la)?(la-1):i;//求累加的上限  
73.     for(j=ma;;j<=mi;j++)  
74.     {  
75.        c+=a[j]b[i-j];  
76.     }  
77.     d=c/1000;//求进位标志  
78.     if(c>999)  
79.         c%=1000;//取c的后3位  
80.      k[i] = c;//保存至表示乘积的数组k[]  
81.      
82.   }  
83.   e = k[0] + 1000*d;//求出乘积的最高位  
84.   fp = fopen("res.txt","w+");  
85.   fprintf(fp,"%d",a[0]);//打印被乘数的最高位  
86.   write(a,la);//打印被乘数其他位数  
87.   fprintf(fp,"%d",b[0]);//打印乘数的最高位  
88.   write(b,lb);//打印乘数其他位数  
89.   fprintf(fp,"%d",e);//打印乘积的最高位  
90.   write(k,la+lb-1);//打印乘积其他位数  
91.   fclose(fp);  
92. }  

 

 

 

  

  

 

 

                           表二

  从最低位的20开始，保留个位数字“0”，把个位以外的数“2”进到前一位；把次低位的39加上低位进上来的2得41，保留个位数字“1”，把“4”进到前一位；以此类推，直至最高位的16,16加上地位进上来的4得20，保留“0”，把2进到最高位，得乘积为