[算法 笔记]大数相乘

  今天去参加腾讯笔试,其中有一道选答题:大数相乘问题。在编写代码的过程,我突然发现以前写的原始的大数相乘是一个很简陋的源码。所以,下午找个时间重新写了一份。

  大数相乘:两个超出整型限制的两个数相乘,例如,两个50位的正数相乘。

  最简陋的方式,就是按照乘法的计算过程来模拟计算:

       1 2

    × 3 6

   ---------- ---- 其中,上标数字为进位数值。

     71 2  --- 在这个计算过程中,2×6=12。本位保留2,进位为1.这里是一个简单的计算过程,如果在高位也需要进位的情况下,如何处理?

    3 6

    -----------

    413  2

 

  开始比较简陋的源码就是基本模拟上述的乘法过程:

 1 int compute_value( const char *lhs, int lhs_start_index,
 2                    const char *rhs, int rhs_start_index,
 3                    char *result )
 4 {
 5     int i = 0, j = 0, res_i = 0;
 6     int tmp_i = 0;
 7     int carry = 0;
 8 
 9     for ( i = lhs_start_index; lhs[i] != '\0'; ++i, ++tmp_i )
10     {
11         res_i = tmp_i;  // 在每次计算时,结果存储的位需要增加。如上述模拟过程中,第二行。
12         carry = 0;
13 
14         for ( j = rhs_start_index; rhs[j] != '\0'; ++j )
15         {
16             int tmp_lhs = lhs[i] - '0';
17             int tmp_rhs = rhs[j] - '0';
18             carry += ( result[res_i] - '0' );       // 这里需要注意,因为每次计算并不能保证以前计算结果的进位都消除,因此这里是加号。
19             carry += ( tmp_lhs * tmp_rhs );      // 并且以前的计算结果也需要考虑。
20             result[res_i++] = ( carry % 10 + '0' );
21             carry /= 10;
22         }
23 
24         while ( carry )  // 当乘数的一次计算完成,可能存在有的进位没有处理。因此,这里对其进行处理。
25         {
26             result[res_i++] = ( carry % 10 + '0' );
27             carry /= 10;
28         }
29     }
30     result[res_i] = '\0';
31 
32     return res_i;
33 }

  上述源码能够完成基本的运算,比如非负数,非小数等情况。如果在传递的参数是不规则或不正确,例如,“  -1234”, "+1234", “- 123”。这里的处理有点类似于atoi函数(http://blog.csdn.net/v_july_v/article/details/9024123)的处理。

  因此,大数相乘是一个陷阱多多的函数,其中一个容易被忽略的陷阱就是:按照正常人的习惯,高数位存放在最左端,个位放在右端,例如 1223的字符串为“1223”,但是在上述函数计算过程中,是从左到右计算的。这是一个非常容易被忽略的错误,也是最致命的错误之一。

  整体思路如下:

  1. 检查参数的合理性;

  2. 判断传递参数是正负数;

  3. 判断传递参数是否为小数;

  4. 翻转并计算数值;

  5. 如果存在小数,需要将结果中小数点的放置;

  6. 如果计算结果为负值,则将结果设置为负值。

  全部源码如下:

  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 #include <string.h>
  4 #include <assert.h>
  5 #include <ctype.h>
  6 
  7 // 翻转data[start...end-1]
  8 void reverse_data( char *data, int start, int end  )
  9 {
 10     char temp = '0';
 11 
 12     assert( data != NULL && start < end );
 13     while ( start < end )
 14     {
 15         temp = data[start];
 16         data[start] = data[--end];
 17         data[end] = temp;
 18         ++start;
 19     }
 20 }
 21 
 22 /**< 判断数据中数值的合法性,以及非空格字符的起始位置。
 23  *  1. 是否均有正确的正负号,例如"+123", "-123"等
 24  *  2. 字符串中字符是否均是数字字符。
 25  *  3. 字符串开始部分放入空格是合法的,例如,”  +123“等
 26  *  4. 只有一个'.'标记
 27  **< 参数:
 28  * @data: 表示传入字符;
 29  * @nonspace_index:非空格起点
 30  **< 返回值:若数据是合法数值,则返回1;否则返回0;
 31  */
 32 int check_logic( const char *data, int *nonspace_index )
 33 {
 34     int flag = 1;
 35     int start = 0;
 36     int point_cnt = 0;
 37 
 38     assert( data != NULL );
 39     /* PS. if data is not space(' ', '\n'), isspace() return 0. */
 40     for ( ; isspace( data[start] )!= 0
 41             && data[start] != '\0'; ++start );
 42 
 43     // 判断数据是否为负数
 44     *nonspace_index = start;
 45     if ( data[start] == '-' || data[start] == '+' )
 46     {
 47         ++start;
 48     }
 49 
 50     /* PS. if ch is digit character, isdigit() return 1; otherwise return 0. */
 51     for ( ; data[start] != '\0'; ++start )
 52     {
 53         if ( isdigit( data[start] ) || data[start] == '.' )
 54         {
 55             // 判断数据为小数的格式是否正确。
 56             if ( data[start] == '.' && point_cnt == 0 )
 57             {
 58                 ++point_cnt;
 59             }
 60             else if ( point_cnt > 1 )
 61             {
 62                 break;
 63             }
 64         }
 65     }
 66 
 67     // 若小数点后面无数据,则不合法
 68     if ( data[start] != '\0' )
 69     {
 70         flag = 0;
 71     }
 72 
 73     return flag;
 74 }
 75 
 76 /**< notice: 传入到该函数的数据已经被翻转后的数值。即,最左边为个位,最右边为最高位
 77  **< return: 结果数据的长度。
 78  */
 79 int compute_value( const char *lhs, int lhs_start_index,
 80                    const char *rhs, int rhs_start_index,
 81                    char *result )
 82 {
 83     int i = 0, j = 0, res_i = 0;
 84     int tmp_i = 0;
 85     int carry = 0;
 86 
 87     for ( i = lhs_start_index; lhs[i] != '\0'; ++i, ++tmp_i )
 88     {
 89         res_i = tmp_i;
 90         carry = 0;
 91 
 92         for ( j = rhs_start_index; rhs[j] != '\0'; ++j )
 93         {
 94             int tmp_lhs = lhs[i] - '0';
 95             int tmp_rhs = rhs[j] - '0';
 96             carry += ( result[res_i] - '0' );
 97             carry += ( tmp_lhs * tmp_rhs );
 98             result[res_i++] = ( carry % 10 + '0' );
 99             carry /= 10;
100         }
101 
102         while ( carry )
103         {
104             result[res_i++] = ( carry % 10 + '0' );
105             carry /= 10;
106         }
107     }
108     result[res_i] = '\0';
109 
110     return res_i;
111 }
112 
113 int has_point( char *data, int index, int *point_index )
114 {
115     int start = index;
116 
117     for ( ; data[start] != '\0'; ++start )
118     {
119         if ( data[start] == '.' )
120         {
121             *point_index = start;
122             break;
123         }
124     }
125 
126     return ( data[start] != '\0' );
127 }
128 
129 int is_neg( char *data, int *index )
130 {
131     int flag = 0;
132     int start = *index;
133     if ( data[start] == '-' || data[start] == '+' )
134     {
135         if ( data[start] == '-' )
136             flag = 1;
137         ++start;
138     }
139 
140     *index = start;
141     return flag;
142 }
143 
144 void copy_c( char * dest, const char *src )
145 {
146     while ( *src != '\0' )
147     {
148         if ( *src != '.' )
149             *dest++ = *src;
150         src++;
151     }
152 }
153 
154 int compute_decimals( char *lhs, int lhs_point_index,
155                       char *rhs, int rhs_point_index,
156                       char *result  )
157 {
158     int lhs_length = strlen( lhs );
159     int rhs_length = strlen( rhs );
160     int result_point_index = lhs_length + rhs_length;
161     int result_length = 0, i = 0;
162     char *tmp_lhs = NULL;
163     char *tmp_rhs = NULL;
164 
165     // 计算在结果中放置小数点的位置,根据的是两个小数部分长度之和
166     // 例如,rhs = "12.345", lhs = "3.45", result = "xxx.xxxxx"
167     result_point_index -= ( lhs_point_index + rhs_point_index );
168 
169     // 分配并拷贝
170     if ( lhs_point_index )
171     {
172         tmp_lhs = (char *)malloc( sizeof(char) * lhs_length );
173         assert( tmp_lhs != NULL );
174         copy_c( tmp_lhs, lhs );
175         tmp_lhs[lhs_length - 1] = '\0';
176     }
177     else
178     {
179         tmp_lhs = lhs;
180     }
181 
182     if ( rhs_point_index )
183     {
184         tmp_rhs = (char *)malloc( sizeof(char) * rhs_length );
185         assert( tmp_rhs != NULL );
186         copy_c( tmp_rhs, rhs );
187         tmp_rhs[rhs_length - 1] = '\0';
188     }
189     else
190     {
191         tmp_rhs = rhs;
192     }
193 
194     // tmp_lhs比lhs少一个小数点
195     reverse_data( tmp_lhs, 0, lhs_length - 1 );
196     reverse_data( tmp_rhs, 0, rhs_length - 1 );
197     result_length = compute_value( tmp_lhs, 0, tmp_rhs, 0, result );
198     for ( i = result_length; i > result_point_index; --i )
199     {
200         result[i] = result[i - 1];
201     }
202 
203     result[result_point_index] = '.';
204     ++result_length;
205     result[result_length] = '\0';
206 
207     // 释放资源
208     if ( lhs_point_index )
209     {
210         free( tmp_lhs ), tmp_lhs = NULL;
211     }
212 
213     if ( rhs_point_index )
214     {
215         free( tmp_rhs ), tmp_rhs = NULL;
216     }
217 
218     return result_length;
219 }
220 
221 // 返回结果数值的长度
222 int big_number_multiply( char *lhs, char *rhs, char *result )
223 {
224     int lhs_start_index = 0, lhs_point_index = 0;
225     int rhs_start_index = 0, rhs_point_index = 0;
226     int result_is_neg = 0;
227     int result_length = 0;
228 
229     assert( lhs != NULL && rhs != NULL && result != NULL );
230     // 检查数据的合法性
231     if ( !(check_logic( lhs, &lhs_start_index )
232             && check_logic( rhs, &rhs_start_index )) )
233     {
234         return -1;
235     }
236 
237     // 检查数据是否为负数
238     result_is_neg = is_neg( lhs, &lhs_start_index );
239     if ( is_neg( rhs, &rhs_start_index) )
240     {
241         result_is_neg = result_is_neg == 1 ?  0 : 1;
242     }
243 
244     // 检查是否两个数值中存在一个小数或两者都是小数
245     if ( !( has_point( lhs, lhs_start_index, &lhs_point_index )
246             && has_point( rhs, rhs_start_index, &rhs_point_index ) ) )
247     {
248         reverse_data( lhs, lhs_start_index, strlen(lhs) );
249         reverse_data( rhs, rhs_start_index, strlen(rhs) );
250         result_length = compute_value( lhs, lhs_start_index,
251                                        rhs, rhs_start_index, result );
252         reverse_data( lhs, lhs_start_index, strlen(lhs) );
253         reverse_data( rhs, rhs_start_index, strlen(rhs) );
254     }
255     else // 一个数值中有小数部分
256     {
257         result_length = compute_decimals(
258                           lhs + lhs_start_index, lhs_point_index - lhs_start_index + 1,
259                           rhs + rhs_start_index, rhs_point_index - rhs_start_index + 1,
260                           result );
261     }
262     if ( result_is_neg )
263         result[result_length++] = '-';
264     reverse_data( result, 0, result_length );
265     result[result_length] = '\0';
266 
267     return result_length;
268 }
269 
270 int main()
271 {
272     char lhs[] = "-1.235";
273     char rhs[] = "    3.456";
274     char result[40];
275 
276     memset( result, '0', sizeof(result) );
277 
278     big_number_multiply( lhs, rhs, result );
279     printf( "%s\n", result );
280     return 0;
281 }
View Code

 

  这里我仅仅提供了一个简单的测试,欢迎大家来指导!!

posted @ 2013-10-26 19:18  life91  阅读(4149)  评论(0编辑  收藏  举报