[算法 笔记]大数相乘

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

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

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

　　　　   1 2

　　　　× 3 6

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

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

　　　　3 6

　   -----------

　　　　4¹3  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

 

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