大整数乘法问题.docx

大整数乘法问题.docx

《大整数乘法问题.docx》由会员分享，可在线阅读，更多相关《大整数乘法问题.docx（16页珍藏版）》请在冰豆网上搜索。

大整数乘法问题

2.4大整数乘法问题

算法设计思想：

（1）大整数的存储

我们知道，在编译系统中，整型数据类型的最大存储空间为8字节，也就是最大能存储232的数据。

即使使用双精度浮点数据类型（double），也只能存储最大1.798×10308的数据。

如果需要计算10200数量级的整数的乘法，利用的现有的数据类型就无法实现了。

所以，为了实现大整数的乘法，需要自己定义一种数据类型，以及对应的基本运算。

在该算法中，为了调试和处理方便，我们采用静态整型数组来存放大整数，即用数组的每一个元素存放大整数一位上的数字。

然后，分别定义用数组存放的大整数的加法、减法和移位运算。

这样，我们就可以用定义的大整数进行后面分治乘法的运算。

（2）分治思想

将位数是2的次幂的n位的十进制大整数X和Y各分为2段，每段的长为n/2位。

则有，X=A×10n/2+B，Y=C×10n/2+D。

这样，乘积问题变为这样的分治问题：

XY=（A×10n/2+B）（C×10n/2+D）=AC×10n+（AD+CB）×10n/2+BD①

如果按①式计算XY，我们可得时间复杂度T（n）=O（n2）（详细论证在课本上）。

显然，用①式来计算X和Y的乘积并不比乘法竖式更有效。

为了改进算法的计算复杂性，我们把XY写成另一种形式：

XY=AC×10n+[（A-B）（D-C）+AC+BD]×10n/2+BD        ②

用解递归方程的套用公式法可得②式的时间复杂度T（n）=O（nlog3）=O（n1.59），该结果有效地减小了算法的时间复杂度。

因此，根据②式，我们得到了大整数相乘的分治算法。

（3）高位补0的位数处理方法

我们提出的分治思想在理论上是可行的，但是在算法具体实现中，程序的递归过程要求每次进行分治计算，即带入②式的大整数X和Y有如下要求：

1．X和Y的位数相同。

2．X和Y的位数是2的次幂。

按照这样的限制，我们只能计算n×n位（n=1,2,4,8,16...）的整数乘法。

显然，这样的算法有很大的局限性，它不能处理像132×12758这样更为普遍的问题。

因此，我们在算法里采用这样的处理方法：

当大整数需要进行分治乘法时，在两个乘数的高位补0，使它们的位数达到相同的2的次幂；分治结束后，将得到的乘积的高位多余的0去除，进行加减等非分治算法运算；以此类推。

采用这种高位补0的位数处理方法，实现了任意位大整数的乘法。

除了上述三点之外，程序对鲁棒性做了增强，对非法输入和文件错误进行了检测。

程序设计代码：

/*头文件大数乘法问题.h*/

#ifndefKNAP_H

#defineKNAP_H

#include

#include

#include

usingnamespacestd;

/*定义数制，范围2到10*/

#defineSCALE10

/*整数的最大位数*/

constintMax=1000;

/*表示整数的结构体*/

structInteger

{

boolpositive;//整数的正负

shortnum[Max];//整数的各位数字，下标从0开始

intlength;//整数的位数

};

/*两个整数的乘法类*/

classMultiply

{

public:

Multiply（char*in,char*out）;//构造函数

~Multiply（）;//析构函数

voidOutputProduct（）;//输出大整数的乘积

protected:

shortCharToInt（charch）;//将数字字符转化成整型

intAddDigit（Integer&X,Integer&Y）;//将位数补充到相同2的次幂位

voidInitialInteger（Integer&integer,ifstream&in）;//文件初始化大整数

voidOutputInteger（Integerinteger）;//输出大整数integer

voidClearZero（Integer&integer）;//去除大整数高位多余的0

boolPositiveXGreaterThanY（IntegerX,IntegerY）;//判断是否非负X大于非负Y

boolEqualsToZero（Integerinteger）;//判断是否等于0

IntegerZero（）;//返回大整数0

IntegerGetAbsolute（Integerinteger）;//返回大整数integer的绝对值

IntegerGetNegative（Integerinteger）;//返回大整数integer的负值

IntegerGetLeft（Integerinteger）;//取大整数integer左一半

IntegerGetRight（Integerinteger）;//取大整数integer右一半

IntegerLeftShifting（Integerinteger,intdigit）;//大整数向左移digit位，低位补0

IntegerPlus（IntegerX,IntegerY）;//大整数加法

IntegerSubtract（IntegerX,IntegerY）;//大整数减法

IntegerSameSignPlus（IntegerX,IntegerY）;//同号大整数加法

IntegerSameSignSubtract（IntegerX,IntegerY）;//同号大整数减法

IntegerOneDigitMultiply（IntegerX,IntegerY）;//非负1位大整数乘法

IntegerFreeMultiply（IntegerX,IntegerY）;//任意大整数乘法

IntegerNDigitsMultiply（IntegerX,IntegerY,intn）;//2的n次幂乘法，高位补0

private:

Integerinteger_X,integer_Y;//数组存储的大整数

ofstreamfout;//输出结果文件

};

#endif

/*函数实现文件大数乘法问题.cpp*/

#include"大数乘法问题.h"

Multiply:

:

Multiply（char*in,char*out）:

fout（out）

{

try//非法输入检测

{

ifstreamfin（in）;

if（!

fin）

throw"输入文件无法打开！

\n";

InitialInteger（integer_X,fin）;//文件初始化大整数integer_X

fin.ignore（100,'\n'）;//冲掉回车

InitialInteger（integer_Y,fin）;//文件初始化大整数integer_Y

fin.close（）;//关闭文件

if（!

fout）

throw"输出文件无法打开！

\n";

}

catch（char*string）

{

cout<

system（"pause"）;

exit（0）;

}

}

Multiply:

:

~Multiply（）

{

if（fout）

fout.close（）;

}

voidMultiply:

:

OutputProduct（）

{

Integertemp=FreeMultiply（integer_X,integer_Y）;

ClearZero（temp）;

OutputInteger（temp）;

}

shortMultiply:

:

CharToInt（charch）

{

shorttemp;

switch（ch）

{

case'0':

temp=0;break;

case'1':

temp=1;break;

case'2':

temp=2;break;

case'3':

temp=3;break;

case'4':

temp=4;break;

case'5':

temp=5;break;

case'6':

temp=6;break;

case'7':

temp=7;break;

case'8':

temp=8;break;

case'9':

temp=9;break;

default:

temp=-1;break;

}

if（temp==-1）

throw"Error:

输入存在非数字字符！

\n";

if（temp>=SCALE）

throw"Error:

输入不符合数制！

\n";

returntemp;

}

intMultiply:

:

AddDigit（Integer&X,Integer&Y）

{

intdigit=0;

if（X.length>Y.length）

digit=X.length;

else

digit=Y.length;//取二者最大位数

inti;

for（i=0;pow（2.0,i）

digit=（int）pow（2.0,i）;//取满足二者的最小2的次幂

for（i=digit-1;i>=X.length;i--）

X.num[i]=0;

for（i=digit-1;i>=Y.length;i--）

Y.num[i]=0;//高位补0，使位数达到2的次幂

X.length=Y.length=digit;//改变二者的位数

returndigit;//返回2的次幂

}

voidMultiply:

:

InitialInteger（Integer&integer,ifstream&in）

{

if（in.peek（）=='-'）

{

in.get（）;

integer.positive=false;

}

else

integer.positive=true;

inti;

chartemp[Max];

for（i=0;in.peek（）!

='\n'&&!

in.eof（）;i++）//读到回车处或文件结束

in>>temp[i];

integer.length=i;

for（i=0;i

integer.num[i]=CharToInt（temp[integer.length-i-1]）;//将每一位字符转化为整型

}

voidMultiply:

:

OutputInteger（Integerinteger）

{

if（integer.length==0）//结果为0

fout<

else

{

if（integer.positive==false）//结果为负数

fout<<'-';

for（inti=integer.length-1;i>-1;i--）

fout<

}

}

voidMultiply:

:

ClearZero（Integer&integer）

{

for（inti=integer.length-1;integer.num[i]==0&&i>=0;i--）

integer.length--;

}

boolMultiply:

:

PositiveXGreaterThanY（IntegerX,IntegerY）

{

if（X.length>Y.length）//X位数大于Y

returntrue;

elseif（X.length

returnfalse;

else

for（inti=X.length-1;i>=0;i--）//从高位逐位比较

if（X.num[i]>Y.num[i]）//某一位X大于Y

returntrue;

elseif（X.num[i]

returnfalse;

returntrue;//X=Y返回true

}

boolMultiply:

:

EqualsToZero（Integerinteger）

{

for（inti=integer.length-1;i>=0;i--）

if（integer.num[i]!

=0）

returnfalse;

returntrue;

}

IntegerMultiply:

:

Zero（）

{

Integertemp;

temp.length=0;//0的位数定义为0

temp.positive=true;

temp.num[0]=0;//0的第一位默认为0

returntemp;

}

IntegerMultiply:

:

GetAbsolute（Integerinteger）

{

if（integer.positive==false）

integer.positive=true;

returninteger;

}

IntegerMultiply:

:

GetNegative（Integerinteger）

{

if（integer.positive==true）

integer.positive=false;

else

integer.positive=true;

returninteger;

}

IntegerMultiply:

:

GetLeft（Integerinteger）

{

Integertemp;

temp.length=integer.length/2;//位数为一半

temp.positive=true;//默认是正数

for（inti=0;i

temp.num[i]=integer.num[i+temp.length];

ClearZero（temp）;//去除高位多余的0

returntemp;

}

IntegerMultiply:

:

GetRight（Integerinteger）

{

Integertemp;

temp.length=integer.length/2;//位数为一半

temp.positive=true;//默认是正数

for（inti=0;i

temp.num[i]=integer.num[i];

ClearZero（temp）;//去除高位多余的0

returntemp;

}

IntegerMultiply:

:

LeftShifting（Integerinteger,intdigit）

{

if（!

EqualsToZero（integer））

{

for（inti=integer.length+digit-1;i>=digit-1;i--）

integer.num[i]=integer.num[i-digit];//原有位向高位移digit位

for（inti=digit-1;i>=0;i--）

integer.num[i]=0;//低位补0

integer.length=integer.length+digit;//位数加digit

}

returninteger;

}

IntegerMultiply:

:

Plus（IntegerX,IntegerY）

{

if（X.positive==Y.positive）//同号

returnSameSignPlus（X,Y）;

else//异号

if（X.positive）//X正Y负

{

Y=GetNegative（Y）;//Y取负得正

returnSameSignSubtract（X,Y）;

}

else//Y正X负

{

X=GetNegative（X）;//X取负得正

returnSameSignSubtract（Y,X）;

}

}

IntegerMultiply:

:

Subtract（IntegerX,IntegerY）

{

if（X.positive==Y.positive）//同号

returnSameSignSubtract（X,Y）;

else

{

Y=GetNegative（Y）;//Y取负得正

returnSameSignPlus（X,Y）;

}

}

IntegerMultiply:

:

SameSignPlus（IntegerX,IntegerY）

{

inti;

intcarry_flag=0;//进位

for（i=0;i

{

if（X.num[i]+Y.num[i]+carry_flag>SCALE-1）//当为加法需要进位

{

X.num[i]=（X.num[i]+Y.num[i]+carry_flag）%SCALE;

carry_flag=1;

}

else

{

X.num[i]=X.num[i]+Y.num[i]+carry_flag;

carry_flag=0;

}

}

if（i

{

while（i

{

if（X.num[i]+carry_flag>SCALE-1）//需要进位

{

X.num[i++]=（X.num[i]+carry_flag）%SCALE;

carry_flag=1;

}

else

{

X.num[i++]=X.num[i]+carry_flag;

carry_flag=0;

}

}

}

elseif（i

{

while（i

{

if（Y.num[i]+carry_flag>SCALE-1）//需要进位

{

X.num[i++]=（Y.num[i]+carry_flag）%SCALE;

carry_flag=1;

}

else

{

X.num[i++]=Y.num[i]+carry_flag;

carry_flag=0;

}

}

}

if（carry_flag==1）//最高位存在进位

{

X.num[i]=1;

X.length=i+1;

}

else

{

X.length=i;

}

returnX;

}

IntegerMultiply:

:

SameSignSubtract（IntegerX,IntegerY）

{

if（PositiveXGreaterThanY（X,Y））//如果绝对值X>=Y

{

inti;

intcarry_flag=0;//借位

boolfirst_0=true;//高位第一次出现0

inttop_digit_0=0;//记录结果最高位+1的下标

inttop_digit=0;//记录结果最高位下标

for（i=0;i

{

if（X.num[i]-carry_flag

{

X.num[i]=（X.num[i]-carry_flag+SCALE-Y.num[i]）;

carry_flag=1;

}

else

{

X.num[i]=X.num[i]-carry_flag-Y.num[i];

carry_flag=0;

}

if（X.num[i]==0）//高位出现0

{

if（first_0）//且是第一次出现0

{

first_0=false;//再出现0则不是第一次出现0

top_digit_0=i;//记录结果最高位+1的下标

}

}

else

{

first_0=true;

top_digit=i;

}

}

if（carry_flag==1）//最高位存在借位

{

X.num[i]=X.num[i]-carry_flag;

if（X.num[i]==0&&firs