C/C++“大数相加算法”_cpp大数相加函数-CSDN博客

函数原型介绍：

[cpp]view plaincopy 
   
 // first和second：任意大小的十进制字符串整数，该函数主要解决超出int和long值域的大型整数加法运算  
 // first和second的取值范围：可以是"99999999999999999"、"-9999999999999999999"和"0"等  
 // result：存储相加的结果  
 void add_large_integer(const char* first, const char* second, char* result);  

实现原理介绍：整数相加问题可以归结为两个子问题，即”正整数相加和正整数相减“，相加需要考虑进位的情况，相减则考虑借位的情况，按照测试驱动开发的原则，写上若干测试用例，如下所示：

[cpp]view plaincopy 
   
 #include <assert.h>  
 #include <string>  
 using namespace std;  
   
 int main(int argc, char* argv[])  
 {  
     char result[2048] = {0};  
    
     // 用例1  
     add_large_integer("99999999999999999999", "99999999999999999999", result);  
     assert(0 == strcmp(result, "199999999999999999998"));  
        
     // 用例2  
     result[0] = '\0';  
     add_large_integer("-99999999999999999999", "6666666666666666666666666666666", result);  
     assert(0 == strcmp(result, "6666666666566666666666666666667"));  
    
     return 0;  
 }  

将要用到的辅助函数列表，原型如下：

[cpp]view plaincopy 
   
 // 跳过连续无效数字  
 const char* skip_serial_number(const char* integer, int number);  
   
 // 反转字符串  
 char* reverse_string(char* p);  
   
 // 判断是否正整数  
 bool is_positive_integer(const char* integer);  
   
 // 判断是否负整数  
 bool is_negative_integer(const char* integer);  
   
 // 正整数相加  
 void add_positive_integer(const char* first, const char* second, char* result);  
   
 // 正整数相减  
 void minus_positive_integer(const char* large, const char* small, char* result);  

函数实现：

[cpp]view plaincopy 
   
 // 大数相加算法  
 void add_large_integer(const char* first, const char* second, char* result)  
 {  
     // 数据有效性校验  
     if ( !(is_positive_integer(first) || is_negative_integer(first)) ||  
          !(is_positive_integer(second) || is_negative_integer(second)) )  
     {  
         return;  
     }  
    
     // 两个正整数相加  
     if ( is_positive_integer(first) && is_positive_integer(second) )  
     {  
         // 跳过无效字符  
         first = skip_serial_number(first, '0');  
         second = skip_serial_number(second, '0');  
    
         // 保存两个整数  
         string first_number(first ? first : "");  
         string second_number(second ? second : "");  
    
         // 字符串反转，使得个位对齐  
         first = reverse_string((char*)first_number.c_str());  
         second = reverse_string((char*)second_number.c_str());  
   
         add_positive_integer(first, second, result); // 两个正整数相加  
    
         reverse_string(result); // 反转result字符串结果  
     }  
     // 两个负整数相加  
     else if ( is_negative_integer(first) && is_negative_integer(second) )  
     {  
         strcpy(result, "-"); // 添加负号  
   
         add_large_integer(++first, ++second, ++result); // 跳过负号，变为正整数相加  
     }  
     // 正整数和负整数相加  
     else  
     {  
         if ( is_negative_integer(first) ) // first为负数，second为正数  
         {  
             ++first; // 移除负号;  
    
             // 跳过无效符号  
             first = skip_serial_number(first, '0');  
             second = skip_serial_number(second, '0');  
    
             // 保存两个正整数  
             string first_number(first ? first : "");  
             string second_number(second ? second : "");  
                
             // 比较两个正整数的大小  
             int first_len = first ? strlen(first) : 0;  
             int second_len = second ? strlen(second) : 0;  
             int retcode = (first_len > second_len) ? 1 : \  
                 ((first_len < second_len) ? -1 : strcmp(first, second));  
                
             if ( 0 == retcode )  
             {  
                 strcpy(result, "0"); // 相加和等于零  
                 return;  
             }  
             else  
             {  
                 // 字符串反转，使得个位对齐  
                 first = reverse_string((char*)first_number.c_str());  
                 second = reverse_string((char*)second_number.c_str());  
   
                 if ( retcode < 0 ) // 负数的绝对值小于正数，相加后为正数  
                 {  
                     minus_positive_integer(second, first, result); // 求绝对值的差  
                 }  
                 else // 负数的绝对值大于正数，相加后为负数  
                 {  
                     strcpy(result, "-"); // 添加负号  
                     minus_positive_integer(first, second, ++result); // 求绝对值的差  
                 }  
   
                 reverse_string(result); // 反转result字符串结果  
             }  
         }  
         else // first为正数，second为负数  
         {  
             add_large_integer(second, first, result); // 递归调用  
         }  
     }  
 }  

[cpp]view plaincopy 
   
 // 跳过连续无效数字  
 const char* skip_serial_number(const char* integer, int number)  
 {  
     while ( integer && *integer && (*integer == number) )  
     {  
         ++integer;  
     }  
    
     return integer;  
 }  

[cpp]view plaincopy 
   
 // 反转字符串  
 char* reverse_string(char* p)  
 {  
     int length = strlen(p);  
    
     for (int i = 0; i < (length / 2); ++i)  
     {  
         swap(p[i], p[length - i - 1]);  
     }  
    
     return p;  
 }  

[cpp]view plaincopy 
   
 // 判断是否正整数  
 bool is_positive_integer(const char* integer)  
 {  
     while ( integer && *integer )  
     {  
         if ( (*integer < '0') || (*integer > '9') )  
         {  
             return false;  
         }  
    
         ++integer;  
     }  
    
     return true;  
 }  

[cpp]view plaincopy 
   
 // 判断是否负整数  
 bool is_negative_integer(const char* integer)  
 {  
     // 负数符号  
     if ( integer && *integer && (*integer == '-') )  
     {  
         return is_positive_integer(++integer); // 移除负号后判断是否正整数  
     }  
    
     return false;  
 }  

[cpp]view plaincopy 
   
 // 正整数相加  
 void add_positive_integer(const char* first, const char* second, char* result)  
 {  
     // 结束条件  
     if ( !first || !second || !result || (!*first && !*second) )  
     {  
         return;  
     }  
    
     // 计算三者的和以及进位  
     int first_value = *first ? (*first - '0') : 0;  
     int second_value = *second ? (*second - '0') : 0;  
     int result_value = *result ? (*result - '0') : 0;  
     int sum = first_value + second_value + result_value;  
    
     // 计算当前位的值  
     *result = (sum % 10) + '0';  
    
     // 计算进位的值  
     if ( sum >= 10 )  
     {  
         *(result + 1) = (sum / 10) + '0';  
         *(result + 2) = '\0'; // 添加结束符  
     }  
     else  
     {  
         *(result + 1) = '\0'; // 添加结束符  
     }  
    
     // 递归调用  
     first = *first ? ++first : first;  
     second = *second ? ++second : second;  
     add_positive_integer(first, second, ++result);  
 }  

[cpp]view plaincopy 
   
 // 正整数相减  
 void minus_positive_integer(const char* large, const char* small, char* result)  
 {  
     // 结束条件  
     if ( !large || !small || !result || (!*large && !*small) )  
     {  
         return;  
     }  
    
     // 计算当前位的差值  
     int borrow_value = *result ? 1 : 0; // 通过result保存借位情况  
     int large_value = *large ? ((*large - '0') - borrow_value) : 0;  
     int small_value = *small ? (*small - '0') : 0;  
        
     if ( large_value < small_value )  
     {  
         *result = ((large_value + 10) - small_value) + '0'; // 借位相减  
         *(result + 1) = '-'; // 借出一位  
         *(result + 2) = '\0'; // 添加结束符  
    
     }  
     else  
     {  
         *result = (large_value - small_value) + '0';  
         *(result + 1) = '\0'; // 添加结束符  
     }     
    
     // 递归调用  
     small = *small ? ++small : small;  
     minus_positive_integer(++large, small, ++result);  
 }  