演算法用連結串列模擬大整數加法運算

dongyu2013發表於2014-04-15
演算法

例如：9->9->9->NULL

+                      1->NULL

      1->0->0->0->NULL


思路：

使用遞迴，能夠實現從前往後計算。


[cpp] view plaincopyprint?
  1. // LinkTable.cpp : 定義控制檯應用程式的入口點。  
  2. //  
  3.   
  4. #include "stdafx.h"  
  5. #include   
  6. #include   
  7. using namespace std;  
  8.   
  9. //連結串列的結構體  
  10. struct node  
  11. {  
  12.     char val;  
  13.     node * next;  
  14. };  
  15.   
  16. //建立連結串列  
  17. struct node * create( string & str_link )  
  18. {  
  19.     int len = str_link.length();  
  20.   
  21.     struct node * phead = new node();     //帶有表頭的連結串列，表頭中不儲存任何元素  
  22.     struct node * preNode = phead;  
  23.     for( int i=0; i
  24.     {  
  25.         struct node * pNode = new node();  
  26.         pNode->val = str_link[i];  
  27.         pNode->next = NULL;  
  28.         preNode->next = pNode;  
  29.         preNode = pNode;  
  30.     }  
  31.     return phead;  
  32. }  
  33.   
  34. //輸出連結串列  
  35. void out_link( struct node * phead )  
  36. {  
  37.     if( phead == NULL )  
  38.         return;  
  39.     struct node * pNode = phead->next;  
  40.     while( pNode )  
  41.     {  
  42.         cout <val;  
  43.         pNode = pNode->next;  
  44.     }  
  45.     cout <
  46. }  
  47.   
  48. //求無表頭連結串列的長度  
  49. //返回-1為連結串列不存在  
  50. int link_length( struct node* pNode )  
  51. {  
  52.     if(!pNode) return -1;  
  53.   
  54.     int len=0;  
  55.     while( pNode )  
  56.     {  
  57.         pNode = pNode->next;  
  58.         len++;  
  59.     }  
  60.     return len;  
  61. }  
  62.   
  63.   
  64. //大數相加遞迴演算法  
  65. //pNode1, pNode2為兩個中間運算結點，但不是頭結點  
  66. struct node * add( struct node * pNode1, struct node * pNode2, int & carry )  
  67. {  
  68.     if( !pNode1  ) return pNode2;  
  69.     if( !pNode2  ) return pNode1;  

  1. "white-space: pre;">    //為了引數簡潔，這裡增大了計算量，可以將連結串列長度作為引數傳進來  
  2.     int len1 = link_length( pNode1 );  
  3.     int len2 = link_length( pNode2 );  
  4.   
  5.   
  6.     if( len1 == len2 )  
  7.     {  
  8.         if( len1==1 )             //遞迴終止條件  
  9.         {  
  10.             struct node * pNode = new node();  
  11.             int sum = (pNode1->val - '0' ) + ( pNode2->val -'0');  
  12.             carry = sum/10;  
  13.             pNode->val = sum%10 + '0';  
  14.             pNode->next = NULL;  
  15.             return pNode;  
  16.         }  
  17.         else  
  18.         {  
  19.             int carry_cur=0;  
  20.             struct node * pNode = new node();  
  21.             struct node * pNext = add( pNode1->next, pNode2->next, carry_cur );  
  22.             int sum = (pNode1->val - '0' ) + ( pNode2->val -'0') + carry_cur;  
  23.             carry = sum/10;  
  24.             pNode->val = sum%10 + '0';  
  25.             pNode->next = pNext;  
  26.             return pNode;  
  27.         }  
  28.     }  
  29.   
  30.     if( len1>len2 )  
  31.     {  
  32.         int carry_cur=0;  
  33.             struct node * pNode = new node();  
  34.             struct node * pNext = add( pNode1->next, pNode2, carry_cur );  
  35.             int sum = (pNode1->val - '0' ) + carry_cur;  
  36.             carry = sum/10;  
  37.             pNode->val = sum%10 + '0';  
  38.             pNode->next = pNext;  
  39.             return pNode;  
  40.     }  
  41.   
  42.     if( len1
  43.     {  
  44.         int carry_cur=0;  
  45.             struct node * pNode = new node();  
  46.             struct node * pNext = add( pNode1, pNode2->next, carry_cur );  
  47.             int sum = (pNode2->val - '0' ) + carry_cur;  
  48.             carry = sum/10;  
  49.             pNode->val = sum%10 + '0';  
  50.             pNode->next = pNext;  
  51.             return pNode;  
  52.     }  
  53.   
  54.     return NULL;  
  55. }  
  56.   
  57. struct node * add( struct node * phead1, struct node * phead2 )  
  58. {  
  59.     if( !phead1 || !phead1->next ) return phead2;  
  60.     if( !phead2 || !phead2->next ) return phead1;  
  61.   
  62.     int carry = 0;  
  63.     struct node * pNode = add( phead1->next, phead2->next, carry );  
  64.   
  65.     if( carry > 0 )                     //有進位，則需要多一個結點  
  66.     {  
  67.         struct node * pCarry = new node();  
  68.         pCarry->val = '0' + carry;  
  69.         pCarry->next = pNode;  
  70.         pNode = pCarry;  
  71.     }  
  72.   
  73.     struct node * phead = new node();  
  74.     phead->next = pNode;  
  75.     return phead;  
  76. }  
  77.   
  78. void test()  
  79. {  
  80.     string str;  
  81.     cout <"Input the first link:"<
  82.     cin >> str;  
  83.     struct node *phead1 = create( str );  
  84.       
  85.     cout <"Input the second link:"<
  86.     cin >> str;  
  87.     struct node *phead2 = create( str );  
  88.   
  89.     struct node * phead = add( phead1, phead2);  
  90.       
  91.     cout<"The result is:" <
  92.     out_link( phead );  
  93.   
  94. }  
  95.   
  96. int _tmain(int argc, _TCHAR* argv[])  
  97. {  
  98.     test();  
  99.     return 0;  
  100. }  

來自 “ ITPUB部落格 ” ，連結：http://blog.itpub.net/29012686/viewspace-1142668/，如需轉載，請註明出處，否則將追究法律責任。

相關文章