C++ 大数

来源：互联网发布：淘宝图片清理工具3.0 编辑：程序博客网时间：2024/06/05 15:52

前言:由于计算机运算是有模运算,数据范围的表示有一定限制,如整型int(C++中int 与long相同)表达范围是(-2^31~2^31-1),unsigned long(无符号整数)是(0~2^32-1),都约为几十亿.如果采用实数型,则能保存最大的double只能提供15~16位的有效数字,即只能精确表达数百万亿的数.因此,在计算位数超过十几位的数时,不能采用现有类型,只能自己编程计算.
高精度计算通用方法:高精度计算时一般用一个数组来存储一个数,数组的一个元素对应于数的一位(当然,在以后的学习中为了加快计算速度,也可用数组的一个元素表示数的多位数字,暂时不讲),表示时,由于数计算时可能要进位,因此为了方便,将数由低位到高位依次存在数组下标对应由低到高位置上,另外,我们申请数组大小时,一般考虑了最大的情况,在很多情况下,表示有富余,即高位有很多0,可能造成无效的运算和判断,因此,我们一般将数组的第0个下标对应位置来存储该数的位数.如数:3485(三千四百八十五)，表达在数组a[10]上情况是:
下标　　0  　 1　   2   　3   　　4 　  5    6    7    8    9
内容　　4   　5  　 8   　4   　　3  　 0    0    0    0    0
说明：位数   个位  十位  百位　千位
具体在计算加减乘除时方法就是小学时采用的列竖式方法．
注：高精度计算时一般用正数，对于负数，通过处理符号位的修正．
一．高精度数的存储
１．如对数采用的字符串输入
#include <iostream>
#include <cstring>
using namespace std;
const int N=100;//最多100位
int main()
{
int a[N+1],i;
string s1;
cin>>s1;//数s1
memset(a,0,sizeof(a)); //数组清0
a[0]=s1.length(); //位数
for(i=1;i<=a[0];i++) a[i]=s1[a[0]-i]-'0';//将字符转为数字并倒序存储．
return 0;
}
2.直接读入
#include <iostream>
using namespace std;
const int N=100;//最多100位
int main()
{
int a[N+1],i,s,key;
cin>>key;//数key
memset(a,0,sizeof(a)); //数组清0
i=0;//第0位
while(key)  //当key大于0
{
  a[++i]=key%10;//取第i位的数
  key=key/10;
}
a[0]=i; //共i位数
return 0;
}
3.直接初始化(用a[]存储)
初始化为0: memset(a,0,sizeof(a));
初始化为1: memset(a,0,sizeof(a));a[0]=1;a[1]=1;

以下程序都只写函数，不写完整程序，所有高精度数存储都满足上述约定。
二.高精度数比较
int compare(int a[],int b[])   //比较a和b的大小关系，若a>b则为1，a<b则为-1,a=b则为0
{int i;
if (a[0]>b[0]) return 1;//a的位数大于b则a比b大
if (a[0]<b[0]) return -1;//a的位数小于b则a比b小
for(i=a[0];i>0;i--)  //从高位到低位比较
     {if (a[i]>b[i]) return 1;
      if (a[i]<b[i]) return -1;}
return 0;//各位都相等则两数相等。
}
三、高精度加法
int plus(int a[],int b[]) //计算a=a+b
{int i,k;
k=a[0]>b[0]?a[0]:b[0]; //k是a和b中位数最大的一个的位数
for(i=1;i<=k;i++)
    {a[i+1]+=(a[i]+b[i])/10;  //若有进位，则先进位
    a[i]=(a[i]+b[i])%10;}  //计算当前位数字,注意：这条语句与上一条不能交换。
if(a[k+1]>0) a[0]=k+1;  //修正新的a的位数（a+b最多只能的一个进位）
               else a[0]=k;
return 0;
}
四、高精度减法
int gminus(int a[],int b[]);//计算a=a-b，返加符号位0:正数 1:负数
{ int flag,i
  flag=compare(a,b); //调用比较函数判断大小
if (falg==0)//相等
  {memset(a,0,sizeof(a));return 0;}  //若a=b，则a=0,也可在return前加一句a[0]=1,表示是 1位数0
if(flag==1) //大于
  {  for(i=1;i<=a[0];i++)
      {  if(a[i]<b[i]){ a[i+1]--;a[i]+=10;} //若不够减则向上借一位
        a[i]=a[i]-b[i];}
     while(a[a[0]]==0) a[0]--; //修正a的位数
    return 0;}
if (flag==-1)//小于  则用a=b-a,返回-1
    { for(i=1;i<=b[0];i++)       {  if(b[i]<a[i]){ b[i+1]--;b[i]+=10;} //若不够减则向上借一位
        a[i]=b[i]-a[i];}
      a[0]=b[0];
     while(a[a[0]]==0) a[0]--; //修正a的位数
    return -1;}
}
五、高精度乘法1(高精度乘单精度数，单精度数是指通常的整型数)
int multi1(int a[],long  key) //a=a*key,key是单精度数
{int i,k;
if (key==0){memset(a,0,sizeof(a));a[0]=1;return 0;} //单独处理key=0
for(i=1;i<=a[0];i++)a[i]=a[i]*key;//先每位乘起来
for(i=1;i<=a[0];i++){a[i+1]+=a[i]/10;a[i]%=10;} //进位
//注意上一语句退出时i=a[0]+1
while(a[i]>0) {a[i+1]=a[i]/10;a[i]=a[i]%10;i++;a[0]++];}  //继续处理超过原a[0]位数的进位,修正a的位数
return 0;
}

C++高精度模板(2)

直接copy过来的……
LANG: C++
TASK: 高精度模板
*/
//高精度模板，注意本模板并没有考虑中间会出现负数的情况
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <assert.h>
#include <ctype.h>
#include <map>
#include <string>
#include <set>
#include <bitset>
#include <utility>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <iostream>
#include <fstream>
#include <list>

using namespace std;

const int MAXL = 500;
struct BigNum
{
    int num[MAXL];
    int len;
};

//高精度比较 a > b return 1, a == b return 0; a < b return -1;
int Comp(BigNum &a, BigNum &b)
{
    int i;
    if(a.len != b.len) return (a.len > b.len) ? 1 : -1;
    for(i = a.len-1; i >= 0; i--)
        if(a.num[i] != b.num[i]) return (a.num[i] > b.num[i]) ? 1 : -1;
    return 0;
}

//高精度加法
BigNum Add(BigNum &a, BigNum &b)
{
    BigNum c;
    int i, len;
    len = (a.len > b.len) ? a.len : b.len;
    memset(c.num, 0, sizeof(c.num));
    for(i = 0; i < len; i++)
    {
        c.num[i] += (a.num[i]+b.num[i]);
        if(c.num[i] >= 10)
        {
            c.num[i+1]++;
            c.num[i] -= 10;
        }
    }
    if(c.num[len]) len++;
    c.len = len;
    return c;
}
//高精度减法,保证a >= b
BigNum Sub(BigNum &a, BigNum &b)
{
    BigNum c;
    int i, len;
    len = (a.len > b.len) ? a.len : b.len;
    memset(c.num, 0, sizeof(c.num));
    for(i = 0; i < len; i++)
    {
        c.num[i] += (a.num[i]-b.num[i]);
        if(c.num[i] < 0)
        {
            c.num[i] += 10;
            c.num[i+1]--;
        }
    }
    while(c.num[len] == 0 && len > 1) len--;
    c.len = len;
    return c;
}
//高精度乘以低精度，当b很大时可能会发生溢出int范围,具体情况具体分析
//如果b很大可以考虑把b看成高精度
BigNum Mul1(BigNum &a, int &b)
{
    BigNum c;
    int i, len;
    len = a.len;
    memset(c.num, 0, sizeof(c.num));
    //乘以0，直接返回0
    if(b == 0)
    {
        c.len = 1;
        return c;
    }
    for(i = 0; i < len; i++)
    {
        c.num[i] += (a.num[i]*b);
        if(c.num[i] >= 10)
        {
            c.num[i+1] = c.num[i]/10;
            c.num[i] %= 10;
        }
    }
    while(c.num[len] > 0)
    {
        c.num[len+1] = c.num[len]/10;
        c.num[len++] %= 10;
    }
    c.len = len;
    return c;
}

//高精度乘以高精度,注意要及时进位，否则肯能会引起溢出,但这样会增加算法的复杂度，
//如果确定不会发生溢出, 可以将里面的while改成if
BigNum Mul2(BigNum &a, BigNum &b)
{
    int     i, j, len = 0;
    BigNum c;
    memset(c.num, 0, sizeof(c.num));
    for(i = 0; i < a.len; i++)
        for(j = 0; j < b.len; j++)
        {
            c.num[i+j] += (a.num[i]*b.num[j]);
            if(c.num[i+j] >= 10)
            {
                c.num[i+j+1] += c.num[i+j]/10;
                c.num[i+j] %= 10;
            }
        }
    len = a.len+b.len-1;
    while(c.num[len-1] == 0 && len > 1) len--;
    if(c.num[len]) len++;
    c.len = len;
    return c;
}

//高精度除以低精度,除的结果为c, 余数为f
void Div1(BigNum &a, int &b, BigNum &c, int &f)
{
    int i, len = a.len;
    memset(c.num, 0, sizeof(c.num));
    f = 0;
    for(i = a.len-1; i >= 0; i--)
    {
        f = f*10+a.num[i];
        c.num[i] = f/b;
        f %= b;
    }
    while(len > 1 && c.num[len-1] == 0) len--;
    c.len = len;
}
//高精度*10
void Mul10(BigNum &a)
{
    int i, len = a.len;
    for(i = len; i >= 1; i--)
        a.num[i] = a.num[i-1];
    a.num[i] = 0;
    len++;
    //if a == 0
    while(len > 1 && a.num[len-1] == 0) len--;
}

//高精度除以高精度，除的结果为c，余数为f
void Div2(BigNum &a, BigNum &b, BigNum &c, BigNum &f)
{
    int i, len = a.len;
    memset(c.num, 0, sizeof(c.num));
    memset(f.num, 0, sizeof(f.num));
    f.len = 1;
    for(i = len-1;i >= 0;i--)
    {
        Mul10(f);
        //余数每次乘10
        f.num[0] = a.num[i];
        //然后余数加上下一位
        ///利用减法替换除法
        while(Comp(f, b) >= 0)
        {
            f = Sub(f, b);
            c.num[i]++;
        }
    }
    while(len > 1 && c.num[len-1] == 0)len--;
    c.len = len;
}
void print(BigNum &a)
{
    int i;
    for(i = a.len-1; i >= 0; i--)
        printf("%d", a.num[i]);
    puts("");
}
//将字符串转为大数存在BigNum结构体里面
BigNum ToNum(char *s)
{
    int i, j;
    BigNum a;
    a.len = strlen(s);
    for(i = 0, j = a.len-1; s[i] != '\0'; i++, j--)
        a.num[i] = s[j]-'0';
    return a;
}

void Init(BigNum &a, char *s, int &tag)
{
    int i = 0, j = strlen(s);
    if(s[0] == '-') {j--; i++; tag *= -1;}
    a.len = j;
    for(; s[i] != '\0'; i++, j--)
        a.num[j-1] = s[i]-'0';
    //print(a);
}

int main()
{
    BigNum a, b;
    char s1[100], s2[100];
    while(scanf("%s %s", s1, s2) != EOF)
    {
        int tag = 1;
        Init(a, s1, tag);
        Init(b, s2, tag);
        a = Mul2(a, b);
        if(a.len == 1 && a.num[0] == 0)
        {
            puts("0");
        }
        else
        {
            if(tag < 0) putchar('-');
            print(a);
        }
    }
    return 0;
}