设为首页收藏本站
切换到窄版

鱼C论坛

 找回密码
 立即注册
鱼C论坛»论坛 › 编程语言专区 › C\C++交流 › 数据结构
返回列表 发新帖
查看: 945|回复: 2

[已解决]数据结构

[复制链接]
Echo。
发表于 2020-12-7 10:44:54 | 显示全部楼层 |阅读模式

马上注册，结交更多好友，享用更多功能^_^

您需要 登录 才可以下载或查看，没有账号？立即注册

x
[问题描述]设计一个程序实现两个任意 长的整数的求和运算

[输入形式]按中国对于长整数的表示习惯，每四位一一组， 组间用逗号隔开

[输出形式]每四位一组，组间用逗号隔开

【评分标准】任何整形变量的范围是：-（215-1）~（215-1）。采用恰当的存储结构，如：利用双向循环链表实现长整数的存储，每个结点中仅存十进制数的4位，即不超过9999的非负整数，整个链表视为万位制数。可以利用头结点数据域的符号代表长整数的符号，用其绝对值表示元素结点数目。相加过程中不要破坏两个操作数链表。两操作数的头指针存于指针数组中是简化程序结构的一种方法。不能给长整数的位数规定上限。

【选作内容】修改上述程序，使它在整形量范围是-（2n-1）~（2n-1）的计算机上都能有效地运行。其中，n是由程序读入的参量。
最佳答案
月排行榜 / 总排行榜
xieglt
2020-12-7 14:44:37
本帖最后由 xieglt 于 2020-12-7 14:53 编辑

后面才看到要考虑符号。又改了下，一个有符号的版本

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>

  5. #define BASE                (10000)
  6. #define        NUM_LEN                (4)
  7. #define        _BASE_SIZE        (1024)
  8. #define ISINIT(p)        ((p->_data != 0) && (p->_flag == 0))

  10. typedef struct tagInteger
  11. {
  12.         int * _data;
  13.         int _size;
  14.         int _len;
  15.         int _signed;
  16.         int _flag;
  17. }INTEGER,*LPINTEGER;

  19. int _InitInteger(LPINTEGER n,int size = 0)
  20. {
  21.         size = ((size == 0) ? _BASE_SIZE : size);
  22.        
  23.         n->_size = 0;
  24.         n->_data = (int *)malloc(size * sizeof(int));
  25.        
  26.         if(n->_data == 0)
  27.         {
  28.                 return 0;
  29.         }

  31.         memset(n->_data,0,size * sizeof(int));
  32.         n->_len = 0;
  33.         n->_size = size;
  34.         n->_flag = 0;
  35.         return 1;
  36. }

  38. void _UninitInteger(LPINTEGER n)
  39. {
  40.         if(ISINIT(n))
  41.         {
  42.                 free(n->_data);
  43.         }
  44. }

  46. int _ResizeInteger(LPINTEGER n,int _size = 0)
  47. {
  48.         int len = n->_size;
  49.        
  50.         if(!ISINIT(n))
  51.         {
  52.                 return _InitInteger(n,_size);
  53.         }
  54.                
  55.         if(_size < _BASE_SIZE)
  56.         {
  57.                 n->_size += _BASE_SIZE;
  58.         }
  59.         else
  60.         {
  61.                 n->_size += _size;
  62.         }
  63.                
  64.         n->_data = (int *)realloc(n->_data,n->_size * sizeof(int));
  65.                
  66.         if(n->_data == 0)
  67.         {
  68.                         return 0;
  69.         }
  70.        
  71.         memset(n->_data + len,0,(n->_size - len) * sizeof(int));
  72.         return 1;
  73. }

  75. int _String2Integer(LPINTEGER pNum,char * number)
  76. {
  77.         int i = 0;
  78.         int nRet = 0;
  79.         char cByte = 0;
  80.         int value = 0;
  81.         int power = 0;
  82.         int index =0;
  83.         int len = strlen(number);
  84.         int size = len / NUM_LEN + (len % NUM_LEN == 0 ? 0 : 1);
  85.         int flag = 0;

  87.         do
  88.         {
  89.                 if(len == 0)
  90.                 {
  91.                         break;
  92.                 }

  94.                
  95.                 if(number[0]=='-' || number[0]=='+')
  96.                 {
  97.                         if(number[0] == '-')
  98.                         {
  99.                                 flag = 1;
  100.                         }
  101.                        
  102.                         number ++;
  103.                         len --;
  104.                 }
  105.                
  106.                 if(!ISINIT(pNum) && _InitInteger(pNum,size) == 0)
  107.                 {
  108.                         break;
  109.                 }

  111.                 if(size > pNum->_size && _ResizeInteger(pNum,size) == 0)
  112.                 {
  113.                         break;
  114.                 }
  115.                
  116.                 for(i=0 ; i<len ; i++)
  117.                 {
  118.                         if(number[i]<'0' || number[i]>'9')
  119.                         {
  120.                                 break;
  121.                         }
  122.                 }
  123.                 if(i < len--)
  124.                 {
  125.                         break;
  126.                 }


  129.                 for(i=len ; i>=0 ; i--)
  130.                 {
  131.                         if((len - i) % NUM_LEN == 0)
  132.                         {
  133.                                 if(len - i != 0)
  134.                                 {
  135.                                         pNum->_data[index++] = value;
  136.                                 }

  138.                                 value = 0;
  139.                                 power = 1;
  140.                         }
  141.                         cByte = number[i] - 0x30;
  142.                         value += power * cByte;
  143.                         power *= 10;
  144.                 }

  146.                 if(value != 0)
  147.                 {
  148.                         pNum->_data[index++] = value;
  149.                 }
  150.                 pNum->_signed = flag;
  151.                 pNum->_len = index;
  152.                 while(pNum->_data[pNum->_len-1] == 0)
  153.                 {
  154.                         pNum->_len--;
  155.                 }
  156.                 nRet = 1;
  157.         }while(0);

  159.         return nRet;
  160. }

  162. int _Integer2String(LPINTEGER pNum,char * number)
  163. {
  164.         int i = 0;
  165.         int nRet = 0;
  166.         char buffer[16] = {0};
  167.        
  168.         do
  169.         {
  170.                 if(!ISINIT(pNum))
  171.                 {
  172.                         break;
  173.                 }

  175.                 if(number == 0)
  176.                 {
  177.                         nRet = pNum->_len * (NUM_LEN + 1) + 1;
  178.                         break;
  179.                 }

  181.                 number[0] = 0;

  183.                 if(pNum->_signed != 0)
  184.                 {
  185.                         strcat(number,"-");
  186.                 }
  187.                
  188.                 for(i=pNum->_len-1 ; i>=0 ; i--)
  189.                 {
  190.                         if(i == pNum->_len-1)
  191.                         {
  192.                                 sprintf(buffer,"%d",pNum->_data[i]);
  193.                         }
  194.                         else
  195.                         {
  196.                                 sprintf(buffer,"%04d",pNum->_data[i]);
  197.                         }
  198.                         strcat(number,buffer);
  199.                         if(i != 0)
  200.                         {
  201.                                 strcat(number,",");
  202.                         }
  203.                 }

  205.                 nRet = strlen(number);
  206.         }while(0);

  208.         return nRet;
  209. }

  211. void _PushBack(LPINTEGER src,int data)
  212. {

  214.         if(src->_len == src->_size)
  215.         {
  216.                 if(!_ResizeInteger(src))
  217.                 {
  218.                         return;
  219.                 }
  220.         }

  222.         src->_data[src->_len++] = data;
  223. }

  225. void _SimpleAdd(LPINTEGER src,LPINTEGER dst)
  226. {
  227.         int sizeofme = src->_len;
  228.         int sizeofyou = dst->_len;
  229.         int len = sizeofme >= sizeofyou ? sizeofme : sizeofyou;
  230.         int i = 0;
  231.         int value = 0;
  232.         int carry = 0;

  234.         for(i=0 ; i<len ; i++)
  235.         {
  236.                 value = carry;
  237.                 if(i < sizeofme)
  238.                 {
  239.                         value += src->_data[i];
  240.                 }

  242.                 if(i < sizeofyou)
  243.                 {
  244.                         value += dst->_data[i];
  245.                 }

  247.                 carry = value / BASE;
  248.                 value %= BASE;

  250.                 if(i < sizeofme)
  251.                 {
  252.                         src->_data[i] = value;
  253.                 }
  254.                 else
  255.                 {
  256.                         _PushBack(src,value);
  257.                 }
  258.         }

  260.         if(carry != 0)
  261.         {
  262.                 if(i < sizeofme)
  263.                 {
  264.                         src->_data[i] = carry;
  265.                 }
  266.                 else
  267.                 {
  268.                         _PushBack(src,carry);
  269.                 }
  270.         }
  271. };

  273. void _SimpleSub(LPINTEGER src,LPINTEGER dst)
  274. {
  275.         int sizeofme = src->_len;
  276.         int sizeofyou = dst->_len;
  277.         int i = 0;
  278.         int value = 0;
  279.         int carry = 0;
  280.        
  281.         for(i=0 ; i<sizeofme ; i++)
  282.         {
  283.                 value = src->_data[i];

  285.                 if(i < sizeofyou)
  286.                 {
  287.                         value -= dst->_data[i];
  288.                 }
  289.                
  290.                 value -= carry;
  291.                
  292.                 if(value < 0)
  293.                 {
  294.                         value += BASE;
  295.                         carry = 1;
  296.                 }
  297.                 else
  298.                 {
  299.                         carry = 0;
  300.                 }
  301.                 src->_data[i] = value;
  302.         }

  304.         while(src->_data[src->_len-1] == 0)
  305.         {
  306.                 src->_len--;
  307.         }
  308. }

  310. int _UnsignedCompare(LPINTEGER src,LPINTEGER dst)
  311. {
  312.         int i = 0;

  314.         if(src->_len > dst->_len)
  315.         {
  316.                 return 1;
  317.         }
  318.         else if(src->_len < dst->_len)
  319.         {
  320.                 return -1;
  321.         }
  322.        
  323.         for(i=src->_len-1 ; i>=0 ; i--)
  324.         {
  325.                 if(src->_data[i] > dst->_data[i])
  326.                 {
  327.                         return 1;
  328.                 }
  329.                 else if(src->_data[i] < dst->_data[i])
  330.                 {
  331.                         return -1;
  332.                 }
  333.         }

  335.         return 0;
  336. }

  338. void _CopyInteger(LPINTEGER dst,LPINTEGER src)
  339. {
  340.         if(!ISINIT(dst))
  341.         {
  342.                 if(!_InitInteger(dst,src->_size))
  343.                 {
  344.                         return;
  345.                 }
  346.         }
  347.         else if(dst->_size < src->_size)
  348.         {
  349.                 if(!_ResizeInteger(dst,src->_size))
  350.                 {
  351.                         return;
  352.                 }
  353.         }

  355.         memcpy(dst->_data,src->_data,src->_size);
  356.         dst->_len = src->_len;
  357.         dst->_signed = src->_signed;
  358. }

  360. void _UnsignedSub(LPINTEGER src,LPINTEGER dst)
  361. {
  362.         INTEGER n;
  363.         int _signed = src->_signed;

  365.         if(_UnsignedCompare(src,dst) == -1)
  366.         {

  368.                 _CopyInteger(&n,dst);
  369.                 _SimpleSub(&n,src);
  370.                 _CopyInteger(src,&n);
  371.                 _UninitInteger(&n);
  372.                 src->_signed = !_signed;
  373.         }
  374.         else
  375.         {
  376.                 _SimpleSub(src,dst);
  377.         }
  378. }

  380. void _AddInteger(LPINTEGER src,LPINTEGER dst)
  381. {
  382.         int _signed = src->_signed - dst->_signed;
  383.         if(_signed == 0)
  384.         {
  385.                 _SimpleAdd(src,dst);
  386.         }
  387.         else
  388.         {
  389.                 _UnsignedSub(src,dst);
  390.         }
  391. }

  393. void _SubInteger(LPINTEGER src,LPINTEGER dst)
  394. {
  395.         int _signed = src->_signed - dst->_signed;
  396.         if(_signed != 0)
  397.         {
  398.                 _SimpleAdd(src,dst);
  399.         }
  400.         else
  401.         {
  402.                 _UnsignedSub(src,dst);
  403.         }
  404. }

  406. int main(int argc, char* argv[])
  407. {
  408.         INTEGER n,m;
  409.         char buffer[128];
  410.         _InitInteger(&n);
  411.         _InitInteger(&m);
  412.         _String2Integer(&n,"-1234567890987654321012345678909876543210123");
  413.         _String2Integer(&m,"99998888777776666655555444433332222111100001234567890");
  414.        
  415.         _AddInteger(&n,&m);
  416.         _Integer2String(&n,buffer);
  417.         _UninitInteger(&n);
  418.         _UninitInteger(&m);
  419.         printf("%s",buffer);
  420.         return 0;
  421. }

复制代码
小甲鱼最新课程 -> https://ilovefishc.com
回复

使用道具 举报

xieglt
发表于 2020-12-7 14:08:59 | 显示全部楼层
用的数组实现
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>

  5. #define BASE                (10000)
  6. #define        NUM_LEN                (4)
  7. #define        _BASE_SIZE        (1024)
  8. #define ISINIT(p)        ((p->_data != 0) && (p->_flag == 0))

  10. typedef struct tagInteger
  11. {
  12.         int * _data;
  13.         int _size;
  14.         int _len;
  15.         int _flag;
  16. }INTEGER,*LPINTEGER;

  18. int _InitInteger(LPINTEGER n,int size = 0)
  19. {
  20.         size = ((size == 0) ? _BASE_SIZE : size);
  21.        
  22.         n->_size = 0;
  23.         n->_data = (int *)malloc(size * sizeof(int));
  24.        
  25.         if(n->_data == 0)
  26.         {
  27.                 return 0;
  28.         }

  30.         memset(n->_data,0,size * sizeof(int));
  31.         n->_len = 0;
  32.         n->_size = size;
  33.         n->_flag = 0;
  34.         return 1;
  35. }

  37. void _UninitInteger(LPINTEGER n)
  38. {
  39.         if(ISINIT(n))
  40.         {
  41.                 free(n->_data);
  42.         }
  43. }

  45. int _ResizeInteger(LPINTEGER n,int _size = 0)
  46. {
  47.         int len = n->_size;
  48.        
  49.         if(!ISINIT(n))
  50.         {
  51.                 return _InitInteger(n,_size);
  52.         }
  53.                
  54.         if(_size < _BASE_SIZE)
  55.         {
  56.                 n->_size += _BASE_SIZE;
  57.         }
  58.         else
  59.         {
  60.                 n->_size += _size;
  61.         }
  62.                
  63.         n->_data = (int *)realloc(n->_data,n->_size * sizeof(int));
  64.                
  65.         if(n->_data == 0)
  66.         {
  67.                         return 0;
  68.         }
  69.        
  70.         memset(n->_data + len,0,(n->_size - len) * sizeof(int));
  71.         return 1;
  72. }

  74. int _String2Integer(LPINTEGER pNum,char * number)
  75. {
  76.         int i = 0;
  77.         int nRet = 0;
  78.         char cByte = 0;
  79.         int value = 0;
  80.         int power = 0;
  81.         int index =0;
  82.         int nLen = strlen(number);
  83.         int size = nLen / NUM_LEN + (nLen % NUM_LEN == 0 ? 0 : 1);

  85.         do
  86.         {
  87.                 if(nLen == 0)
  88.                 {
  89.                         break;
  90.                 }
  91.                
  92.                 if(!ISINIT(pNum) && _InitInteger(pNum,size) == 0)
  93.                 {
  94.                         break;
  95.                 }

  97.                 if(size > pNum->_size && _ResizeInteger(pNum,size) == 0)
  98.                 {
  99.                         break;
  100.                 }
  101.                
  102.                 for(i=0 ; i<nLen ; i++)
  103.                 {
  104.                         if(number[i]<'0' || number[i]>'9')
  105.                         {
  106.                                 break;
  107.                         }
  108.                 }
  109.                 if(i < nLen--)
  110.                 {
  111.                         break;
  112.                 }


  115.                 for(i=nLen ; i>=0 ; i--)
  116.                 {
  117.                         if((nLen - i) % NUM_LEN == 0)
  118.                         {
  119.                                 if(nLen - i != 0)
  120.                                 {
  121.                                         pNum->_data[index++] = value;
  122.                                 }

  124.                                 value = 0;
  125.                                 power = 1;
  126.                         }
  127.                         cByte = number[i] - 0x30;
  128.                         value += power * cByte;
  129.                         power *= 10;
  130.                 }

  132.                 if(value != 0)
  133.                 {
  134.                         pNum->_data[index++] = value;
  135.                 }

  137.                 pNum->_len = index;               
  138.                 nRet = 1;
  139.         }while(0);

  141.         return nRet;
  142. }

  144. int _Integer2String(LPINTEGER pNum,char * number)
  145. {
  146.         int i = 0;
  147.         int nRet = 0;
  148.         char buffer[16] = {0};
  149.        
  150.         do
  151.         {
  152.                 if(!ISINIT(pNum))
  153.                 {
  154.                         break;
  155.                 }

  157.                 if(number == 0)
  158.                 {
  159.                         nRet = pNum->_len * NUM_LEN + 1;
  160.                         break;
  161.                 }

  163.                 number[0] = 0;
  164.                
  165.                 for(i=pNum->_len-1 ; i>=0 ; i--)
  166.                 {
  167.                         if(i == pNum->_len-1)
  168.                         {
  169.                                 sprintf(buffer,"%d",pNum->_data[i]);
  170.                         }
  171.                         else
  172.                         {
  173.                                 sprintf(buffer,"%04d",pNum->_data[i]);
  174.                         }
  175.                         strcat(number,buffer);
  176.                         if(i != 0)
  177.                         {
  178.                                 strcat(number,",");
  179.                         }
  180.                 }

  182.                 nRet = strlen(number);
  183.         }while(0);

  185.         return nRet;
  186. }

  188. void _PushBack(LPINTEGER src,int data)
  189. {

  191.         if(src->_len == src->_size)
  192.         {
  193.                 if(!_ResizeInteger(src))
  194.                 {
  195.                         return;
  196.                 }
  197.         }

  199.         src->_data[src->_len++] = data;
  200. }

  202. void _IntegerAdd(LPINTEGER src,LPINTEGER dst)
  203. {
  204.         int sizeofme = src->_len;
  205.         int sizeofyou = dst->_len;
  206.         int len = sizeofme >= sizeofyou ? sizeofme : sizeofyou;
  207.         int i = 0;
  208.         int value = 0;
  209.         int carry = 0;

  211.         for(i=0 ; i<len ; i++)
  212.         {
  213.                 value = carry;
  214.                 if(i < sizeofme)
  215.                 {
  216.                         value += src->_data[i];
  217.                 }

  219.                 if(i < sizeofyou)
  220.                 {
  221.                         value += dst->_data[i];
  222.                 }

  224.                 carry = value / BASE;
  225.                 value %= BASE;

  227.                 if(i < sizeofme)
  228.                 {
  229.                         src->_data[i] = value;
  230.                 }
  231.                 else
  232.                 {
  233.                         _PushBack(src,value);
  234.                 }
  235.         }

  237.         if(carry != 0)
  238.         {
  239.                 if(i < sizeofme)
  240.                 {
  241.                         src->_data[i] = carry;
  242.                 }
  243.                 else
  244.                 {
  245.                         _PushBack(src,carry);
  246.                 }
  247.         }

  249. };


  252. int main(int argc, char* argv[])
  253. {
  254.         INTEGER n,m;
  255.         char buffer[128];
  256.         _InitInteger(&n);
  257.         _InitInteger(&m);
  258.         _String2Integer(&n,"1234567890987654321012345678909876543210123");
  259.         _String2Integer(&m,"9999888877777666665555544443333222211110000");
  260.         _IntegerAdd(&n,&m);
  261.         _Integer2String(&n,buffer);
  262.         _UninitInteger(&n);
  263.         _UninitInteger(&m);
  264.         printf("%s",buffer);
  265.         return 0;
  266. }

复制代码
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

xieglt
发表于 2020-12-7 14:44:37 | 显示全部楼层    本楼为最佳答案   
本帖最后由 xieglt 于 2020-12-7 14:53 编辑

后面才看到要考虑符号。又改了下，一个有符号的版本

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>

  5. #define BASE                (10000)
  6. #define        NUM_LEN                (4)
  7. #define        _BASE_SIZE        (1024)
  8. #define ISINIT(p)        ((p->_data != 0) && (p->_flag == 0))

  10. typedef struct tagInteger
  11. {
  12.         int * _data;
  13.         int _size;
  14.         int _len;
  15.         int _signed;
  16.         int _flag;
  17. }INTEGER,*LPINTEGER;

  19. int _InitInteger(LPINTEGER n,int size = 0)
  20. {
  21.         size = ((size == 0) ? _BASE_SIZE : size);
  22.        
  23.         n->_size = 0;
  24.         n->_data = (int *)malloc(size * sizeof(int));
  25.        
  26.         if(n->_data == 0)
  27.         {
  28.                 return 0;
  29.         }

  31.         memset(n->_data,0,size * sizeof(int));
  32.         n->_len = 0;
  33.         n->_size = size;
  34.         n->_flag = 0;
  35.         return 1;
  36. }

  38. void _UninitInteger(LPINTEGER n)
  39. {
  40.         if(ISINIT(n))
  41.         {
  42.                 free(n->_data);
  43.         }
  44. }

  46. int _ResizeInteger(LPINTEGER n,int _size = 0)
  47. {
  48.         int len = n->_size;
  49.        
  50.         if(!ISINIT(n))
  51.         {
  52.                 return _InitInteger(n,_size);
  53.         }
  54.                
  55.         if(_size < _BASE_SIZE)
  56.         {
  57.                 n->_size += _BASE_SIZE;
  58.         }
  59.         else
  60.         {
  61.                 n->_size += _size;
  62.         }
  63.                
  64.         n->_data = (int *)realloc(n->_data,n->_size * sizeof(int));
  65.                
  66.         if(n->_data == 0)
  67.         {
  68.                         return 0;
  69.         }
  70.        
  71.         memset(n->_data + len,0,(n->_size - len) * sizeof(int));
  72.         return 1;
  73. }

  75. int _String2Integer(LPINTEGER pNum,char * number)
  76. {
  77.         int i = 0;
  78.         int nRet = 0;
  79.         char cByte = 0;
  80.         int value = 0;
  81.         int power = 0;
  82.         int index =0;
  83.         int len = strlen(number);
  84.         int size = len / NUM_LEN + (len % NUM_LEN == 0 ? 0 : 1);
  85.         int flag = 0;

  87.         do
  88.         {
  89.                 if(len == 0)
  90.                 {
  91.                         break;
  92.                 }

  94.                
  95.                 if(number[0]=='-' || number[0]=='+')
  96.                 {
  97.                         if(number[0] == '-')
  98.                         {
  99.                                 flag = 1;
  100.                         }
  101.                        
  102.                         number ++;
  103.                         len --;
  104.                 }
  105.                
  106.                 if(!ISINIT(pNum) && _InitInteger(pNum,size) == 0)
  107.                 {
  108.                         break;
  109.                 }

  111.                 if(size > pNum->_size && _ResizeInteger(pNum,size) == 0)
  112.                 {
  113.                         break;
  114.                 }
  115.                
  116.                 for(i=0 ; i<len ; i++)
  117.                 {
  118.                         if(number[i]<'0' || number[i]>'9')
  119.                         {
  120.                                 break;
  121.                         }
  122.                 }
  123.                 if(i < len--)
  124.                 {
  125.                         break;
  126.                 }


  129.                 for(i=len ; i>=0 ; i--)
  130.                 {
  131.                         if((len - i) % NUM_LEN == 0)
  132.                         {
  133.                                 if(len - i != 0)
  134.                                 {
  135.                                         pNum->_data[index++] = value;
  136.                                 }

  138.                                 value = 0;
  139.                                 power = 1;
  140.                         }
  141.                         cByte = number[i] - 0x30;
  142.                         value += power * cByte;
  143.                         power *= 10;
  144.                 }

  146.                 if(value != 0)
  147.                 {
  148.                         pNum->_data[index++] = value;
  149.                 }
  150.                 pNum->_signed = flag;
  151.                 pNum->_len = index;
  152.                 while(pNum->_data[pNum->_len-1] == 0)
  153.                 {
  154.                         pNum->_len--;
  155.                 }
  156.                 nRet = 1;
  157.         }while(0);

  159.         return nRet;
  160. }

  162. int _Integer2String(LPINTEGER pNum,char * number)
  163. {
  164.         int i = 0;
  165.         int nRet = 0;
  166.         char buffer[16] = {0};
  167.        
  168.         do
  169.         {
  170.                 if(!ISINIT(pNum))
  171.                 {
  172.                         break;
  173.                 }

  175.                 if(number == 0)
  176.                 {
  177.                         nRet = pNum->_len * (NUM_LEN + 1) + 1;
  178.                         break;
  179.                 }

  181.                 number[0] = 0;

  183.                 if(pNum->_signed != 0)
  184.                 {
  185.                         strcat(number,"-");
  186.                 }
  187.                
  188.                 for(i=pNum->_len-1 ; i>=0 ; i--)
  189.                 {
  190.                         if(i == pNum->_len-1)
  191.                         {
  192.                                 sprintf(buffer,"%d",pNum->_data[i]);
  193.                         }
  194.                         else
  195.                         {
  196.                                 sprintf(buffer,"%04d",pNum->_data[i]);
  197.                         }
  198.                         strcat(number,buffer);
  199.                         if(i != 0)
  200.                         {
  201.                                 strcat(number,",");
  202.                         }
  203.                 }

  205.                 nRet = strlen(number);
  206.         }while(0);

  208.         return nRet;
  209. }

  211. void _PushBack(LPINTEGER src,int data)
  212. {

  214.         if(src->_len == src->_size)
  215.         {
  216.                 if(!_ResizeInteger(src))
  217.                 {
  218.                         return;
  219.                 }
  220.         }

  222.         src->_data[src->_len++] = data;
  223. }

  225. void _SimpleAdd(LPINTEGER src,LPINTEGER dst)
  226. {
  227.         int sizeofme = src->_len;
  228.         int sizeofyou = dst->_len;
  229.         int len = sizeofme >= sizeofyou ? sizeofme : sizeofyou;
  230.         int i = 0;
  231.         int value = 0;
  232.         int carry = 0;

  234.         for(i=0 ; i<len ; i++)
  235.         {
  236.                 value = carry;
  237.                 if(i < sizeofme)
  238.                 {
  239.                         value += src->_data[i];
  240.                 }

  242.                 if(i < sizeofyou)
  243.                 {
  244.                         value += dst->_data[i];
  245.                 }

  247.                 carry = value / BASE;
  248.                 value %= BASE;

  250.                 if(i < sizeofme)
  251.                 {
  252.                         src->_data[i] = value;
  253.                 }
  254.                 else
  255.                 {
  256.                         _PushBack(src,value);
  257.                 }
  258.         }

  260.         if(carry != 0)
  261.         {
  262.                 if(i < sizeofme)
  263.                 {
  264.                         src->_data[i] = carry;
  265.                 }
  266.                 else
  267.                 {
  268.                         _PushBack(src,carry);
  269.                 }
  270.         }
  271. };

  273. void _SimpleSub(LPINTEGER src,LPINTEGER dst)
  274. {
  275.         int sizeofme = src->_len;
  276.         int sizeofyou = dst->_len;
  277.         int i = 0;
  278.         int value = 0;
  279.         int carry = 0;
  280.        
  281.         for(i=0 ; i<sizeofme ; i++)
  282.         {
  283.                 value = src->_data[i];

  285.                 if(i < sizeofyou)
  286.                 {
  287.                         value -= dst->_data[i];
  288.                 }
  289.                
  290.                 value -= carry;
  291.                
  292.                 if(value < 0)
  293.                 {
  294.                         value += BASE;
  295.                         carry = 1;
  296.                 }
  297.                 else
  298.                 {
  299.                         carry = 0;
  300.                 }
  301.                 src->_data[i] = value;
  302.         }

  304.         while(src->_data[src->_len-1] == 0)
  305.         {
  306.                 src->_len--;
  307.         }
  308. }

  310. int _UnsignedCompare(LPINTEGER src,LPINTEGER dst)
  311. {
  312.         int i = 0;

  314.         if(src->_len > dst->_len)
  315.         {
  316.                 return 1;
  317.         }
  318.         else if(src->_len < dst->_len)
  319.         {
  320.                 return -1;
  321.         }
  322.        
  323.         for(i=src->_len-1 ; i>=0 ; i--)
  324.         {
  325.                 if(src->_data[i] > dst->_data[i])
  326.                 {
  327.                         return 1;
  328.                 }
  329.                 else if(src->_data[i] < dst->_data[i])
  330.                 {
  331.                         return -1;
  332.                 }
  333.         }

  335.         return 0;
  336. }

  338. void _CopyInteger(LPINTEGER dst,LPINTEGER src)
  339. {
  340.         if(!ISINIT(dst))
  341.         {
  342.                 if(!_InitInteger(dst,src->_size))
  343.                 {
  344.                         return;
  345.                 }
  346.         }
  347.         else if(dst->_size < src->_size)
  348.         {
  349.                 if(!_ResizeInteger(dst,src->_size))
  350.                 {
  351.                         return;
  352.                 }
  353.         }

  355.         memcpy(dst->_data,src->_data,src->_size);
  356.         dst->_len = src->_len;
  357.         dst->_signed = src->_signed;
  358. }

  360. void _UnsignedSub(LPINTEGER src,LPINTEGER dst)
  361. {
  362.         INTEGER n;
  363.         int _signed = src->_signed;

  365.         if(_UnsignedCompare(src,dst) == -1)
  366.         {

  368.                 _CopyInteger(&n,dst);
  369.                 _SimpleSub(&n,src);
  370.                 _CopyInteger(src,&n);
  371.                 _UninitInteger(&n);
  372.                 src->_signed = !_signed;
  373.         }
  374.         else
  375.         {
  376.                 _SimpleSub(src,dst);
  377.         }
  378. }

  380. void _AddInteger(LPINTEGER src,LPINTEGER dst)
  381. {
  382.         int _signed = src->_signed - dst->_signed;
  383.         if(_signed == 0)
  384.         {
  385.                 _SimpleAdd(src,dst);
  386.         }
  387.         else
  388.         {
  389.                 _UnsignedSub(src,dst);
  390.         }
  391. }

  393. void _SubInteger(LPINTEGER src,LPINTEGER dst)
  394. {
  395.         int _signed = src->_signed - dst->_signed;
  396.         if(_signed != 0)
  397.         {
  398.                 _SimpleAdd(src,dst);
  399.         }
  400.         else
  401.         {
  402.                 _UnsignedSub(src,dst);
  403.         }
  404. }

  406. int main(int argc, char* argv[])
  407. {
  408.         INTEGER n,m;
  409.         char buffer[128];
  410.         _InitInteger(&n);
  411.         _InitInteger(&m);
  412.         _String2Integer(&n,"-1234567890987654321012345678909876543210123");
  413.         _String2Integer(&m,"99998888777776666655555444433332222111100001234567890");
  414.        
  415.         _AddInteger(&n,&m);
  416.         _Integer2String(&n,buffer);
  417.         _UninitInteger(&n);
  418.         _UninitInteger(&m);
  419.         printf("%s",buffer);
  420.         return 0;
  421. }

复制代码
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 1 反对 0

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

小黑屋|手机版|Archiver|鱼C工作室 ( 粤ICP备18085999号-1 | 粤公网安备 44051102000585号)

GMT+8, 2025-11-4 19:59

Powered by Discuz! X3.4

© 2001-2023 Discuz! Team.

快速回复 返回顶部 返回列表