大数运算--除法

#include <iostream>
#include <stdio.h>
#include <cstring>
#include<cassert>
#include <cmath>

using namespace std;
//大数运算最关键的是用进制理解，就是把一个数组元素表示的最大值作为一个进制；如此，最容易的大数运算也是最耗费空间的就是一个元素表示一位数字，即用十进制表示；还有一种折中的方案，是一个元素最大能表示9999，如此用的是10000进制，则下面的baseNum = 10000;本文的实现的是最省空间的方法，一个元素就是一个unsigned short,这样就表示用2^16进制
const int MaxShort = 100;//最多有MaxShort * 2个字节//如果要表示64位int，MaxShort = 4
const int baseNum = pow(2.0,16.0);
const int Shift = 16;
typedef unsigned short Unshort;

typedef struct BigNum
{
int m_len;//可以通过m_len的正负，判断大数的正负。本程序未实现
Unshort m_data[MaxShort];
}BigNum;

void Reverse(char *src);
void GetAbsDecNum(BigNum &bg,char *tgt);

void PrintData(BigNum &a)
{
for (int i=0;i<a.m_len;++i)
{
cout<<a.m_data[i]<<" ";
}
cout<<endl;
}
void Print(BigNum &a)
{
char t[MaxShort];
memset(t,0,sizeof(t));

GetAbsDecNum(a,t);
Reverse(t);
cout<<t<<endl;
}
int AbsComp(BigNum &a,BigNum &b)//a>b,1;a = b,0;a<b,-1
{
if(a.m_len>b.m_len)
return 1;
if (a.m_len<b.m_len)
return -1;

int size = a.m_len -1;
for (int i=size;i>=0;--i)
{
if(a.m_data[i]>b.m_data[i])
return 1;
if(a.m_data[i] <b.m_data[i])
return -1;

}

return 0;

}

BigNum CreateAbsBigNum(char *src)//低位放前，高位放后；
{
BigNum bg;
Unshort *data = bg.m_data;
int b = 0;
while (src[0]!='\0')
{
int i = 0;
int reminder = 0;

while (src[i]!='\0')
{
int divident = src[i] - '0' + reminder * 10;
reminder = divident % baseNum;
src[i] = divident / baseNum + '0';
++i;
}
data[b++] = reminder;

while (*src =='0')
++src;
}
bg.m_len = b;
return bg;

}

BigNum AbsMinus(BigNum &bg1,BigNum &bg2)//bg1 >bg2
{
int left = bg1.m_len;
int right = bg2.m_len;

int carry = 0;
BigNum bg;

for (int i=0;i<right;++i)
{
int tmp = bg1.m_data[i] - bg2.m_data[i] - carry;
if(tmp<0)
{
carry = 1;
bg.m_data[i] = baseNum + tmp;
}
else
{
bg.m_data[i] = tmp;
carry = 0;
}
}

for (int i= right;i<left;++i)
{
int tmp = bg1.m_data[i] - carry;
if (tmp <0)
{
carry = 1;
bg.m_data[i] = baseNum +tmp;
}
else
{
bg.m_data[i] = tmp;
carry = 0;
}
}
bg.m_len = left;
while (bg.m_len>=0 && bg.m_data[bg.m_len -1]==0)
{
--bg.m_len;
}

return bg;

}

int AbsMinus(BigNum &bg1,int n,BigNum &bg2)//必须保证bg1的前n位的数要大于等于bg2//返回减少的位数
{
if(n<bg2.m_len)
{
cerr<<"minus error\n";
exit(1);
}

int size = (bg1.m_len >n) ?n:bg1.m_len;
int beg = bg1.m_len -size;
int len2 = bg2.m_len;
int len1 = bg1.m_len;

int carry = 0;
for (int i=0;i<len2;++i)
{
int tmp = bg1.m_data[i+beg] - bg2.m_data[i] - carry;
if (tmp < 0)
{
carry = 1;
tmp +=baseNum;

}
else
carry = 0;
bg1.m_data[i+beg] = tmp;
}

for (int i = len2 + beg;i<len1;++i)
{
int tmp = bg1.m_data[i] -carry;
if(tmp<0)
{
carry = 1;
tmp +=baseNum;
}
else
carry = 0;

bg1.m_data[i] = tmp;
}

while (bg1.m_len>=0 && bg1.m_data[bg1.m_len - 1] ==0)
--bg1.m_len;

return len1 - bg1.m_len;

}

bool AbsComp(BigNum &a,int n,BigNum &b)//大数的前n位数与b比较大小;a>=b返回true
{
int size = (a.m_len>n)? n:a.m_len;
if(size > b.m_len)
return true;
if(size <b.m_len )
return false;

int end = a.m_len - size;
for (int i=a.m_len -1;i>=end;--i)
{
if(a.m_data[i]>b.m_data[i-end])
return true;
if(a.m_data[i] < b.m_data[i-end])
return false;

}

return true;
}

BigNum AbsDiv(BigNum &bg1,BigNum &bg2)//返回商，bg1变为余数;被除数的位数为n,除数的位数为m,则商的位数最多为n-m+1
{//bg1 >=bg2
BigNum c;
memset(c.m_data,0,sizeof(c.m_data));

int len2= bg2.m_len;
int cLen = bg1.m_len -len2 ;
int i=0;
while(AbsComp(bg1,bg2)>=0)
{
//cout<<"first while:"<<++i<<endl;
int len1=bg1.m_len;
int indx = len1 - len2;
int n = len2;
if(!AbsComp(bg1,len2,bg2))
{
--indx;
++n;
}
//cout<<"n = "<<n<<endl;
Unshort count = 0;
while (AbsComp(bg1,n,bg2))
{
//cout<<"second while : n = "<<n<<endl;
++count;
//cout<<count<<endl;
/*BigNum preBg1 = bg1;
BigNum preBg2 = bg2;
cout<<"pre \n";
Print(preBg1);
Print(preBg2);*/

int tmp = AbsMinus(bg1,n,bg2);
/*cout<<"after \n";
preBg1 = bg1;
preBg2 = bg2;
Print(preBg1);
Print(preBg2);*/

n -= tmp;
}
//cout<<count<<endl;
c.m_data[indx] = count;

}
while(cLen>=0 && c.m_data[cLen] ==0)
--cLen;
c.m_len = cLen +1;

return c;
}

BigNum AbsAdd(BigNum &bg1,BigNum &bg2)
{
int left = bg1.m_len;
int right = bg2.m_len;

int size = left;
int maxLen = right;
BigNum *bgmax = &bg2;
if(size>right)
{
size = right;
maxLen = left;
bgmax = &bg1;
}

int carry = 0;
BigNum bg;
for (int i=0;i<size;++i)
{
int tmp = bg1.m_data[i] + bg2.m_data[i] + carry;
//carry = tmp /baseNum;
carry = tmp>>Shift;
//bg.m_data[i] = tmp &(1<<Shift - 1);
bg.m_data[i] = tmp & 0xffff;
}

for (int i = size;i<maxLen;++i)
{
int tmp = bgmax->m_data[i] + carry;
carry = tmp>>Shift;
//carry = tmp /baseNum;
//bg.m_data[i] = tmp &(1<<Shift - 1);
bg.m_data[i] = tmp & 0xffff;
}

if (carry)
{
bg.m_data[maxLen] = 1;
++maxLen;
}
bg.m_len = maxLen;
return bg;
}

BigNum AbsMul(BigNum &bg1,BigNum &bg2)
{
BigNum bg;
memset(bg.m_data,0,sizeof(bg.m_data));
int i,j;
for (i=0;i<bg1.m_len;++i)
{
size_t carry = 0;
for (j=0;j <bg2.m_len;++j)
{
size_t tmp =  bg.m_data[i+j] + bg1.m_data[i] * bg2.m_data[j] + carry;
bg.m_data[i+j] = tmp %baseNum;
carry = tmp /baseNum;
}
if (carry >0)
{
bg.m_data[i+j] += carry;
}
}
if(bg.m_data[bg1.m_len+bg2.m_len -1] > 0)
bg.m_len = bg1.m_len+bg2.m_len;
else
bg.m_len = bg1.m_len+bg2.m_len -1;

return bg;

}

void GetAbsDecNum(BigNum &bg,char *tgt)
{
int size = bg.m_len;
Unshort *data = bg.m_data;
int b=0;

while (size>0)
{
int i = size - 1;
int reminder = 0;

while (i>=0)
{
int divident = data[i] + reminder * baseNum;
reminder = divident % 10;
data[i] = divident /10;
--i;
}
tgt[b++] = reminder + '0';

while(size>0 && data[size -1]==0)
--size;
}
tgt[b] = '\0';
}

void Reverse(char *src)
{
int size = strlen(src);
int beg = size/2 -1;
for (;beg>=0;--beg)
{
int sym = size -beg -1;
char tmp = src[beg];
src[beg] = src[sym];
src[sym] = tmp;
}
}

int main()
{
char t[100];
memset(t,0,sizeof(t));
char s[] = "6430006453235007";//6430006453235007
BigNum bg = CreateAbsBigNum(s);
//PrintData(bg);
//BigNum bgg = bg;
//Print(bg);
//GetAbsDecNum(bg,t);
//Reverse(t);
//cout<<t<<endl;

memset(t,0,sizeof(t));
char s1[]="1234567932211123423411431421246";//1234567932211123423411431421246
//112126430006453235007
BigNum bg1 = CreateAbsBigNum(s1);
//PrintData(bg1);
//BigNum bg11 = bg1;
//Print(bg11);
//GetAbsDecNum(bg1,t);
//Reverse(t);
//cout<<t<<endl;
BigNum bg2 = AbsDiv(bg1,bg);

memset(t,0,sizeof(t));
GetAbsDecNum(bg2,t);
Reverse(t);
cout<<t<<endl;
}

主要参考：http://hi.baidu.com/erennetwork/blog/item/7fcfe31164dac8134a90a7c2.html

大数除法应该是最难实现的了，假设数组a除以b，实现它有两种方式：
1：用a-=b，循环，直到a<b，记下来执行多少次，则为计算结果；
2：模拟现实，我们手算时是怎么算的，程序就怎么写，
假设a={2 4 2 3 1}，b={2 3}，结果result={0 0 0 0 0}：
先取a[0]a[1]即24，减去b一次，得a={0 1 2 3 1}，result={0 1 0 0 0}；
再取a[1]a[2]即12，发现它小于b，则多取一位，取a[1]a[2]a[3]即123，减b五次，得a={0 0 0 8 1}，result={0 1 0 5 0}；
再取a[3]a[4]即81，减b三次，得a={0 0 0 1 2}，result={0 1 0 5 3}。
如果按照方法一计算，效率是无法容忍的。
假如用11111除以1，方法一要计算11111次，而方法二则只要5次。
下面是方法二的代码，经过了简单的测试（没做数据校验，假设数据都是正常的）：
bool compare(int a[],int n,int b[],int m)//当a>=b时，返回true

{

int i=0;

int j=0;

int temp_n=n;

int temp_m=m;

while(a[i]==0)

{

i++;

temp_n--;

}

while(b[j]==0)

{

j++;

temp_m--;

}

if(temp_n>temp_m)

return true;

else if(temp_n<temp_m)

return false;

else

{

for(i,j;i<n,j<m;i++,j++)

{

if(a[i]>b[j])return true;

if(a[i]<b[j])return false;

}

return true;

}

}

void div(int a[],int n,int b[],int m)

{

int *result;

int *temp;

int start=0;

int end=start+m;

int i;

int flg=0;

int min=0;

result=new int
;

for(i=0;i<n;i++)

result[i]=0;

temp=new int[m+1];

for(i=0;i<m+1;i++)

temp[i]=0;

while(compare(a,n,b,m))

{

while(a[start]==0)

{

start++;

end++;

}

for(i=start;i<end;i++)

{

temp[i-start+1]=a[i];

}

if(!compare(temp,m+1,b,m))

{

end++;

for(i=start;i<end;i++)

temp[i-start]=a[i];

}

while(compare(temp,m+1,b,m))

{

flg=0;

for(i=m;i>=1;i--)

{

min=temp[i]-b[i-1]-flg;

if(min<0)

{

min+=10;

flg=1;

}
else
flg=0;
temp[i]=min;

}

temp[i]-=flg;

result[end-1]++;

}

if(end-start==m)

{

for(i=start;i<end;i++)

{

a[i]=temp[i+1-start];

temp[i+1-start]=0;

}

}

else

{

for(i=start;i<end;i++)

{

a[i]=temp[i-start];

temp[i-start]=0;

}

}

start++;

end=start+m;

}

for(i=0;i<n;i++)

cout<<result[i];

cout<<endl;

delete result;

delete temp;

}