大数运算

于 2011-08-18 21:34:32 发布
阅读量1.3k 收藏 6
点赞数
分类专栏： C++语言 数据结构/算法 文章标签： null delete 优化 c
本文深入探讨了大数运算的基本算法，包括大数加法、减法、乘法和除法的具体实现。通过使用数组模拟操作，详细解释了每一位运算的过程，并提供了相应的代码实现，旨在帮助读者理解和实现大数运算的相关算法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

 这里的大数，指的是超过计算机CPU寄存器表达的数，即超过计算机字长的数。大数运算主要指的是对大数进行数论运算，如加、减、乘、除。出于效率原因，一般的大数运算主要指对无符号类型的数进行数论计算。

通过我收集的一些资料和ACM的一些知识。总结：

（1）、加法用数组模拟，低位加起，带一个进位；

（2）、减法用数组模拟，低位减起，带一个借位；

（3）、乘法用数组模拟，乘数每一位乘以被乘数结果保留；(i+j就是结果的位)；

（4）、除法用数组模拟，累减，不过是通过笔算的除法，从高位减起，不足就从后加数；

有整理的代码，是转载的，原来的网址不记得了，本来没有缩进的我修改了一下，好看些！

/*------------------------------------------------------------------------------
*函数名称： 大数加法
*函数过程：
* 1 比较两个数那一个长
* 2 以长的作为循环次数
* 3 对应项相加 进位存贮直到下高位相加用
* 4 直到循环结束
* 5 !!!!!!没设计负数相加
* 6 加数，被加数是结果都是顺序的，高位到低位
*入口参数：numa，numb，result字符串
*出口参数：无
*编辑环境：winSP2 + VC2003 + C++
*-------------------------------------------------------------------------------
*/
void addition(char *numa, char *numb,char *result) // 计算两大数之和
{
  char *pna = findend(numa); // 指向numa的一个指针。pna 指向加数的最低位，
  char *pnb = findend(numb); //指向numb的一个指针。 pnb 指向被加数的最低位，
  int along=(int)strlen(numa); //标记数字a的长度；
  int blong=(int)strlen(numb); //标记数字b的长度；
  int times = 0; // 标致要计算多少次。
  int carry=0,temp_result; //存贮进位 和临时结果的
  Node *head,   // 用于存贮头指针
       *pstart, // 用于存贮计算时的首指针
       *pnew;   //作于申请新结点 
  head = pstart =new Node; //初始化首结点和头结点。
  pstart -> data = 0;
  pstart -> next = NULL;
  pstart -> ahead = NULL; 

  if (abigerb(numa ,numb)>=1)
    times = (int)strlen(numa); //比较两个字符串长度，以大的作为循环次数
  else {
    times = (int)strlen(numb);
    pna = findend(numb); //交换指针
    pnb = findend(numa);
    along=(int)strlen(numb); //标记数字a的长度；
    blong=(int)strlen(numa); //标记数字b的长度；
  }
  while ((times-- && (times>=0))|| carry != 0) { 
    if(!pstart->next) //如果当前为空结点，则申请新结点
    {
      pnew = new Node;
      pnew -> data = 0;
      pnew -> next = NULL;
      pnew -> ahead = pstart;
      pstart -> next = pnew;
    }
    else //自身的值+新值+进位 作为当前的新值
      temp_result =(pstart->data +(*pna-48)+(*pnb-48)+carry) ; 

    pstart -> data = temp_result%10; //存贮个位
    carry = temp_result/10; //存贮进位
    pstart = pstart -> next; //结点移动
    blong--;
    if(blong>0)pnb--; //指针移向被加数高位
    else *pnb=48; //之后相减就变为了0不作任何运算；
    pna--; //加数指针移动，
  }
  pstart =head; //寻找链表的结尾点
  while(pstart->next != 0) {
    pstart->data += 48; //!!<<<因为我们的输出是字符。所以再此加上48>>>> 逆顺输出
    pstart = pstart->next ;
  }

  int tip = 0; //转为字符串用
  pstart = pstart->ahead ; //找有效字
   //cout<<"/n结果是 : ";
  while(pstart != 0) //输出正序的结果；
  {
    result[tip++] = pstart->data; 
     //cout< data;
    pstart = pstart->ahead ;
  }
  result[tip] = '/0';

  pstart =head; //释放空间
  while(pstart->next != 0) {
    pnew = pstart->next ;delete pstart;
    pstart =pnew; 
  }
  return ;
}
//返回值说明:0是alongblong ; 2是along=blong
int abigerb(char *numa, char *numb) //比较两个数最高位那一个大
{
  int along=(int)strlen(numa); //标记数字a的长度；
  int blong=(int)strlen(numb); //标记数字b的长度；
  char *pna = numa; //指向数A的最高位，
  char *pnb = numb; //指向数B的最高位，
  if (along>blong) return 1;
  if (along==blong)
  {
    while(*pna) //比较两个数那一个大
    {
      if(*pna>*pnb)return 1;
      else if(*pna<*pnb)return 0 ;
      else if(*pna==*pnb){pna++;pnb++;} //1111与1112 
    }
    return 2; //这表明找到最后了还是全相等;
  }
  return 0 ;
}
/*------------------------------------------------------------------------------
*函数名称： 大数减法
*函数过程：
* 1 比较两个数哪一个长
* 2 以长的作为循环次数
* 3 如果两个数长度相等，从最高位开始比直到发现那一个数更大，使大项减去小项
* 4 对应项相减 进位存贮直到下高位相加用
* 5 每一位对应项相减时，处理三种可能的情况，a=b,a>b;
* 6 a<b时，则计算,11-12,111-112,要考虑借位
* 7 直到循环结束
*入口参数：numa，numb，result字符串
*出口参数：无
*-------------------------------------------------------------------------------
*/
void subtract(char *numa, char *numb,char *result)//计算减 
{ 
  char *pna = findend(numa);//指向numa的一个指针，pna 指向减数的最低位， 
  char *pnb = findend(numb);//指向numb的一个指针，pnb 指向被减数的最低位， 
  int along=(int)strlen(numa);//标记数字a的长度； 
  int blong=(int)strlen(numb);//标记数字b的长度； 
  int times = 0; // 标记要计算多少次。 
  int carry=0; //存贮借位 
  int clear0=0; //消除结果最前面无用的'0' 13-5 = 08 的效果！！ 
  int isnegative=0; //用来加上被减数大于减数时补上最后一个负号
  Node *head, // 用于存贮头指针 
       *pstart, // 用于存贮计算时的首指针 
       *pnew; //作于申请新结点 
  head = pstart =new Node;//初始化首结点和头结点。 
  pstart -> data = 0;
  pstart -> next = NULL;
  pstart -> ahead = NULL; 
  if (abigerb(numa ,numb))
    times = strlen(numa);//比较两个字符串长度，以大的作为循环次数
  else //交换位置以降低难度
  { 
    times = strlen(numb);//让数（字符串）长的减去数（字符串）短的
    pna = findend(numb);//交换指针 
    pnb = findend(numa); along=(int)strlen(numb);//标记数字a的长度；
    blong=(int)strlen(numa);//标记数字b的长度； 
    isnegative=1;//标记最后要加上负号 
  } 
  while ((times-- && (times>=0))|| carry != 0)//carry != 0 说没有借位时
  { 
    if(!pstart->next)//如果当前为空结点，则申请新结点 
    { 
      pnew = new Node; 
      pnew -> data = 0;
      pnew -> next = NULL; 
      pnew -> ahead = pstart; 
      pstart -> next = pnew; 
    } 
    if(times<0)//如果计算完之后，借位等于1，，说明必然为负值;
    { 
      pstart -> data = -3 ;//让它等于负号 '-'//-3来源于负号与0相差3。。 
      break; 
    } 
    else { 
      if ( *pna == *pnb )//减数等于被减数时。结果等于直截相减的结果；并置借位为0
      { 
        if(carry==0)
          pstart -> data = (*pna-48)-(*pnb-48); //111-11的情况 
        else { 
          pstart->data = (*pna-48)-(*pnb-48)+10 -carry;//1121-1112 
          carry=1; 
        } 
      } 
      if( *pna > *pnb )//减数大于被减数时。结果等于直截相减的结果；并置借位为0 
      { 
        pstart -> data = (*pna-48)-(*pnb-48)-carry; //存贮个位
        carry=0; 
      } 
      else if( *pna < *pnb )//说明被减数大于减数让结果加10相当于借位 (carry)为1 
      { 
        if(times>0) 
          pstart->data = (*pna-48)-(*pnb-48)+10 -carry;//13-5的情况作为新值
        else 
          pstart->data = (*pnb-48)-(*pna-48)-carry; //3-5作为当前的新值carry=1; 
      } 
    } 
    pstart = pstart -> next; //结点移动 blong--; 
    if(blong>0)
      pnb--;//指针移向被减数高位 
    else 
      *pnb=48; //之后相减就变为了0不作任何运算，其实可以优化的。
              //但代码会长！而且还需要重新开结点。所以放弃； 
    pna--;//被数指针移动， 
  } 
  if(isnegative==1)////加上负号处理。增加一长度并置为负号
  { 
    pnew = new Node; 
    pnew -> data = 0;
    pnew -> next = NULL; 
    pnew -> ahead = pstart; 
    pstart -> next = pnew; 
    pstart->data=-3;//因为寻找链表的结尾点要统一加48。又因为‘-’是45。所以等于‘-3’
  } 
  pstart =head;//寻找链表的结尾点 
  while(pstart->next != 0) { 
    pstart->data += 48;//!!<<<因为我们的输出是字符。所以再此加上48>>>> 逆顺输出 
    pstart = pstart->next ; 
  } 
  int tip = 0;//转为字符串用 
  clear0=0;// 消除结果最前面无用的'0' 13-5 = 08 的效果 ..>>修改字符串的首指针
  pstart = pstart->ahead ;//找有效字 
  while(pstart != 0)//输出正序的结果；
  { 
    if (clear0==0 && ((int)pstart->data)==48&&pstart->ahead!=0)
    // 消除结果最前面无用的'0' ;//不输出任何东西 
    else 
      result[tip++] = pstart->data; 
    if(((int)pstart->data)!=48&&((int)pstart->data)!=45)
      clear0=1;//'－'号 
    pstart = pstart->ahead ; 
  } 
  result[tip] = '\0'; 
  pstart =head; //释放空间 
  while(pstart->next != 0) {
    pnew = pstart->next ;
    delete pstart;
    pstart =pnew; 
  }
  return ; 
}
 /*-----------------------------------------------------------------------------
*函数名称： 大数乘法
*函数过程：
* 1 输入两个大数作为字符串
* 2 作一个双向链表
* 3 两个指针分别指向数字字符串的最低位
* 4 以第一个数的最低的一个位乘以第二个数的所有项存于链表中
* 5 链表首指针移
* 6 重复4，5依次从最低位乘到最高位
* 7 乘完后因为最低位是链表首，最后一位是链表尾。所以在逆顺输出链表。
* 4 直到循环结束
*入口参数：numa，numb，result字符串
*出口参数：无
*-------------------------------------------------------------------------------
*/
void multiply(char *numa, char *numb ,char *result)//计算乘积
{ 
  char *pna = findend(numa);//指向numa的一个指针, pna 指向乘数的最低位， 
  char *pnb = findend(numb);//指向numb的一个指针, pnb 指向被乘数的最低位， 
  int along=(int)strlen(numa);//标记数字a的长度； 
  int blong=(int)strlen(numb);//标记数字b的长度； 
  int carry=0,temp_result;//存贮进位 和临时结果的 
  Node *head, // 用于存贮头指针 
       *pstart, // 用于存贮计算时的首指针 
       *pnew, //作于申请新结点 
       *pgo; //作为每计算完一行时，回到下一行起始节点用,移位标致来用 
  head = pstart =new Node;//初始化首结点和头结点。
  pstart -> data = 0; 
  pstart -> next = NULL; 
  pstart -> ahead = NULL; 
  while (along--) { 
    pgo = pstart;//保存进位点 
    blong = (int)strlen(numb);//初始化长度
    pnb = findend(numb); //初始化指针 
    while ((blong-- && (blong>=0))|| carry != 0) {
      if(!pstart->next)//如果当前为空结点，则申请新结点 
      { 
        pnew = new Node; 
        pnew -> data = 0; 
        pnew -> next = NULL;
        pnew -> ahead = pstart; 
        pstart -> next = pnew; 
      } 
      if(blong<0)
        temp_result = carry ;//处理只有进位的情况 
      else //自身值+新值+进位作为新值 
        temp_result =(pstart->data+(*pna-48)*(*pnb-48)+carry);
      pstart -> data = temp_result%10; //存贮个位 
      carry = temp_result/10; //存贮进位 
      pstart = pstart -> next; //结点移动 
      pnb--; //指针移向被乘数高位
    } 
    pstart = pgo->next; //前进一个位置；
    pna--; //指针移向乘数高位 
  } 
  pstart =head;//寻找链表的结尾点 
  while(pstart->next != 0) { 
    pstart->data += 48;//!!<<<因为我们的输出是字符。所以再此加上48>>>> 逆顺输出
    pstart = pstart->next ; 
  } 
  int tip = 0;//转为字符串用 
  pstart = pstart->ahead ;//找有效字 
  while(pstart != 0)//输出正序的结果； 
  { 
    result[tip++] = pstart->data; 
    pstart = pstart->ahead ; 
  } 
  result[tip] = '\0'; 
  pstart =head; //释放空间 
  while(pstart->next != 0) { 
    pnew = pstart->next ;
    delete pstart; pstart =pnew; 
  } 
  return ; 
}

/*------------------------------------------------------------------------------
*函数名称： 大数除法2-- 
*函数想法：
* 1 用指针指向除数的最高位，保存临时字符串； tempstr[a++] = pna
* 2 如果临时字符串大于被除数，则相减。结果等于余数
* if(tempstr>numb)tempstr = tempstr - numb
* 3 如果小于被除数且指针到头，余数 等于 临时字符串
* if(tempstr * 
*入口参数：numa，numb，result,remainder字符串
*出口参数：无
*-------------------------------------------------------------------------------
*/
void divide2( char *numa, char *numb,char *result,char *remainder)//计算除法2 
{ 
  char one[]="1";//临时字符串.... 
  char one2[]="1";// 
  char zero[]="0";// 
  char numb2[6048];// 
  char tempstr[6018]="";//临时字符串 
  int ia=0,ia2=0;//tempstr的指示器 
  bool moveon=false;//翻转牌 
  char *pna = numa;//指向numa的一个指针。point numa pna 指向减数的最高位， 
  char *pnb = findend(numb);//指向numb的一个指针 //pnb 指向被减数的最低位， 
  Node *head, // 用于存贮头指针 
       *pstart, // 用于存贮计算时的首指针 
       *pnew; //作于申请新结点 
  head = pstart =new Node;//初始化首结点和头结点。
  pstart -> data = 0; 
  pstart -> next = NULL;
  pstart -> ahead = NULL;
  moveon = false; 
  while(*pna) {
    if(!pstart->next)//如果当前为空结点，则申请新结点 
    { 
      pnew = new Node; 
      pnew -> data = 0;
      pnew -> next = NULL;
      pnew -> ahead = pstart;
      pstart -> next = pnew; 
    } 
    ia=(int)strlen(tempstr);//取的长度
    tempstr[ia++] = *(pna++);
    tempstr[ia] ='/0'; //转换为字符串 
    if(tempstr[0]=='0')//处理高位也是0的那种 如00 
    {
      ia2=0;
      while(tempstr[ia2]=='0')
        ++ia2; 
      while(ia2>=1)//清除无用的0 
      { 
        ia=ia2-1; 
        tempstr[ia]=tempstr[ia2]; 
        --ia2; 
      } 
      tempstr[++ia2]='/0'; 
    } 
    while(abigerb(tempstr,numb)>0)//如果tempstr大于等于numb 
    { 
      if(tempstr[0]=='0')//处理高位也是0的那种 如00----此乃冗余代码，留做记念用 
      {
        ia2=0; 
        while(tempstr[ia2]=='0')
          ++ia2;
        if(ia==ia2 ) { 
          moveon = true; 
          break;
        } 
      } 
      strcpy(numb2,numb);
      subtract(tempstr, numb,tempstr);//A-B 
      strcpy(numb,numb2); 
      if(tempstr[0]=='-')//若判断的不准，变为了负数就再加上B。。 
      { 
        strcpy(numb2,numb); 
        addition(tempstr, numb,tempstr);//A-B 
        strcpy(numb,numb2); 
        ia2=0; //修正之后的长度。因为加法中未做负数运算 
        ia=0; //为了消除最后的那一个负号，整体向前移动。
        while(tempstr[ia2]!='/0')
          ++ia2; 
        while(ia2>=1)//清除无用的0
        { 
          tempstr[ia]=tempstr[ia+1]; 
          ++ia; 
          --ia2; 
        } 
        tempstr[ia]='\0'; 
        moveon = true; 
        break; 
      }
      pstart->data++ ; //结果自加
      oveon = true; 
    } 
    if(moveon) 
      pstart = pstart -> next; //结点移动 
  } 
  strcpy(remainder,tempstr);//存贮余数 
  int tip = 0;//转为字符串用 
  pstart =head;//寻找链表的结尾点 
  while(pstart->next != 0) { 
    pstart->data += 48;//!!<<<因为我们的输出是字符。所以再此加上48>>>> 逆顺输出 
    result[tip++] = pstart->data; 
    pstart = pstart->next ; 
  } 
  result[tip] = '/0';//存贮结果 
  pstart =head; //释放空间 
  while(pstart->next != 0) { 
    pnew = pstart->next ;
    delete pstart; 
    pstart =pnew;
  } 
  return ; 
}

/*--------------------------------------------------------------------------
*函数名称： 大数幂
*函数想法：
* 1 B自减1直到，，作为循环控制变量.保存结果； 
* 2 结果初值1 每次乘以A
* 3 重复1、2步骤到结束. 
*入口参数：numa，numb，result字符串
*出口参数：无
*--------------------------------------------------------------------------*/
void power (char *numa, char *numb,char *result) //计算幂
{ 
  char one[]="1"; //临时字符串....
  char one2[]="1"; 
  char zero[]="0"; 
  char numb2[6048]; 
  char remainder[6048]; 
  strcpy(result,one); //给结果初值为1
  strcpy(numb2,numb);
  
  subtract(numb,one ,remainder); //B自减1
  strcpy(numb,numb2);
  
  strcpy(numb2,numb);
  multiply(result,numa,result ); //A自己乘自己
  strcpy(numb,numb2); 
  
  while(strcmp(remainder,zero)>0) //A大于相等B时 就是numb不等于0时
  {
    strcpy(numb2,numb);
    multiply(result,numa,result ); //A自己乘自己
    strcpy(numb,numb2); 
    strcpy(one,one2);
    subtract(remainder,one ,remainder); //B减一
  }
  
  return ;
}


c++带符号的大整数计算器
weixin_64055968的博客
03-19 1227
程序实现了对带符号大整数的加、减、乘、除运算，能够处理包含正负号的大整数，提供了基本的算术运算功能。程序对用户输入进行了简单的错误检查，例如无效选择、除数为零等情况，在发现错误时给出相应的提示并要求重新输入，提高了程序的健壮性。程序可以进一步扩展以支持更多的算术运算，如取模运算、幂运算等，增加了程序的灵活性和实用性。程序在处理加法和减法运算时，通过将减法转化为加上相反数的操作，简化了实现，并减少了重复的代码量，这是一个相对创新的设计。
易语言大数运算模块.ec
12-30
工具-支持库配置-数值计算支持库2.3版 需要勾选这个支持库，然后导入模块直接调用即可。
大数运算miracl 库及使用手册.zip
05-07
大数运算miracl 库及使用手册 MIRACL(Multiprecision Integer and Rational Arithmetic C/c++ Library)是一套由Shamus Software Ltd.所开发的一套关于大数运算函数库，用来设计与大数运算相关的密码学之应用，包含了...
Java实现大数运算的实例代码
08-30
Java实现大数运算的实例代码 Java实现大数运算的实例代码主要介绍了Java实现大数运算的实例代码，小编觉得挺不错的，现在分享给大家，也给大家做个参考。下面将对Java实现大数运算的实例代码进行详细的讲解。 一、...
大数运算库miracl 有了miracl这样的函数库，你可以直接调用函数，来实现你要的公钥密码学的某个功能.zip
03-29
其中，大数运算库如MIRACL（Multiple-precision Integer and Rational Arithmetic Library）为实现复杂的加密算法提供了强大的支持。 MIRACL是一个高效且灵活的大整数运算库，专为处理大整数和复数运算而设计。它...
delphi大数运算单元
10-20
在编程领域，大数运算（BigInt）是指处理超出标准整型数据类型范围的数值计算。在Delphi中，由于内置的Integer、Int64等类型有限的存储范围，当需要进行大数运算时，通常需要借助第三方库或者自定义的算法来实现。...
C语言编写无符号大整数运算
12-23
使用c语言实现的无符号大整数的加、减、乘、除（取整和求余运算），可直接运行
大数运算代码实现
01-16
用python编程实现大数的运算，解决了RSA算法中的大数运算问题
大数运算c语言代码
11-01
C语言无符号整形的大数加法和乘除法的源代码，自己编译通过，并且加有自己理解的注释！大数除法.cpp 大数乘法.cpp 大数加法.cpp
大数运算c++
07-31
大数运算代码；写了大数运算基本的加减乘除、矩阵求逆运算及矩阵加减乘除。采用字符数组的方式实现，可以通过宏来设定所需要的精度，包括小数点后的位数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值