[算法 笔记]大数相乘

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

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

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

　　　　   1 2

　　　　× 3 6

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

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

　　　　3 6

　   -----------

　　　　4¹3  2

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

int compute_value( const char *lhs, int lhs_start_index,
                   const char *rhs, int rhs_start_index,
                   char *result )
{
    int i = 0, j = 0, res_i = 0;
    int tmp_i = 0;
    int carry = 0;

    for ( i = lhs_start_index; lhs[i] != ''; ++i, ++tmp_i )
    {
        res_i = tmp_i;  // 在每次计算时，结果存储的位需要增加。如上述模拟过程中，第二行。
        carry = 0;

        for ( j = rhs_start_index; rhs[j] != ''; ++j )
        {
            int tmp_lhs = lhs[i] - '0';
            int tmp_rhs = rhs[j] - '0';
            carry += ( result[res_i] - '0' );       // 这里需要注意，因为每次计算并不能保证以前计算结果的进位都消除，因此这里是加号。
            carry += ( tmp_lhs * tmp_rhs );　　　　  // 并且以前的计算结果也需要考虑。
            result[res_i++] = ( carry % 10 + '0' );
            carry /= 10;
        }

        while ( carry )　　// 当乘数的一次计算完成，可能存在有的进位没有处理。因此，这里对其进行处理。
        {
            result[res_i++] = ( carry % 10 + '0' );
            carry /= 10;
        }
    }
    result[res_i] = '';

    return res_i;
}

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

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

　　整体思路如下：

　　1. 检查参数的合理性；

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

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

　　4. 翻转并计算数值；

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

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

　　全部源码如下：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>

// 翻转data[start...end-1]
void reverse_data( char *data, int start, int end  )
{
    char temp = '0';

    assert( data != NULL && start < end );
    while ( start < end )
    {
        temp = data[start];
        data[start] = data[--end];
        data[end] = temp;
        ++start;
    }
}

/**< 判断数据中数值的合法性，以及非空格字符的起始位置。
 *  1. 是否均有正确的正负号，例如"+123", "-123"等
 *  2. 字符串中字符是否均是数字字符。
 *  3. 字符串开始部分放入空格是合法的，例如，”  +123“等
 *  4. 只有一个'.'标记
 **< 参数:
 * @data: 表示传入字符;
 * @nonspace_index:非空格起点
 **< 返回值：若数据是合法数值，则返回1；否则返回0；
 */
int check_logic( const char *data, int *nonspace_index )
{
    int flag = 1;
    int start = 0;
    int point_cnt = 0;

    assert( data != NULL );
    /* PS. if data is not space(' ', '
'), isspace() return 0. */
    for ( ; isspace( data[start] )!= 0
            && data[start] != ''; ++start );

    // 判断数据是否为负数
    *nonspace_index = start;
    if ( data[start] == '-' || data[start] == '+' )
    {
        ++start;
    }

    /* PS. if ch is digit character, isdigit() return 1; otherwise return 0. */
    for ( ; data[start] != ''; ++start )
    {
        if ( isdigit( data[start] ) || data[start] == '.' )
        {
            // 判断数据为小数的格式是否正确。
            if ( data[start] == '.' && point_cnt == 0 )
            {
                ++point_cnt;
            }
            else if ( point_cnt > 1 )
            {
                break;
            }
        }
    }

    // 若小数点后面无数据，则不合法
    if ( data[start] != '' )
    {
        flag = 0;
    }

    return flag;
}

/**< notice: 传入到该函数的数据已经被翻转后的数值。即，最左边为个位，最右边为最高位
 **< return: 结果数据的长度。
 */
int compute_value( const char *lhs, int lhs_start_index,
                   const char *rhs, int rhs_start_index,
                   char *result )
{
    int i = 0, j = 0, res_i = 0;
    int tmp_i = 0;
    int carry = 0;

    for ( i = lhs_start_index; lhs[i] != ''; ++i, ++tmp_i )
    {
        res_i = tmp_i;
        carry = 0;

        for ( j = rhs_start_index; rhs[j] != ''; ++j )
        {
            int tmp_lhs = lhs[i] - '0';
            int tmp_rhs = rhs[j] - '0';
            carry += ( result[res_i] - '0' );
            carry += ( tmp_lhs * tmp_rhs );
            result[res_i++] = ( carry % 10 + '0' );
            carry /= 10;
        }

        while ( carry )
        {
            result[res_i++] = ( carry % 10 + '0' );
            carry /= 10;
        }
    }
    result[res_i] = '';

    return res_i;
}

int has_point( char *data, int index, int *point_index )
{
    int start = index;

    for ( ; data[start] != ''; ++start )
    {
        if ( data[start] == '.' )
        {
            *point_index = start;
            break;
        }
    }

    return ( data[start] != '' );
}

int is_neg( char *data, int *index )
{
    int flag = 0;
    int start = *index;
    if ( data[start] == '-' || data[start] == '+' )
    {
        if ( data[start] == '-' )
            flag = 1;
        ++start;
    }

    *index = start;
    return flag;
}

void copy_c( char * dest, const char *src )
{
    while ( *src != '' )
    {
        if ( *src != '.' )
            *dest++ = *src;
        src++;
    }
}

int compute_decimals( char *lhs, int lhs_point_index,
                      char *rhs, int rhs_point_index,
                      char *result  )
{
    int lhs_length = strlen( lhs );
    int rhs_length = strlen( rhs );
    int result_point_index = lhs_length + rhs_length;
    int result_length = 0, i = 0;
    char *tmp_lhs = NULL;
    char *tmp_rhs = NULL;

    // 计算在结果中放置小数点的位置，根据的是两个小数部分长度之和
    // 例如，rhs = "12.345", lhs = "3.45", result = "xxx.xxxxx"
    result_point_index -= ( lhs_point_index + rhs_point_index );

    // 分配并拷贝
    if ( lhs_point_index )
    {
        tmp_lhs = (char *)malloc( sizeof(char) * lhs_length );
        assert( tmp_lhs != NULL );
        copy_c( tmp_lhs, lhs );
        tmp_lhs[lhs_length - 1] = '';
    }
    else
    {
        tmp_lhs = lhs;
    }

    if ( rhs_point_index )
    {
        tmp_rhs = (char *)malloc( sizeof(char) * rhs_length );
        assert( tmp_rhs != NULL );
        copy_c( tmp_rhs, rhs );
        tmp_rhs[rhs_length - 1] = '';
    }
    else
    {
        tmp_rhs = rhs;
    }

    // tmp_lhs比lhs少一个小数点
    reverse_data( tmp_lhs, 0, lhs_length - 1 );
    reverse_data( tmp_rhs, 0, rhs_length - 1 );
    result_length = compute_value( tmp_lhs, 0, tmp_rhs, 0, result );
    for ( i = result_length; i > result_point_index; --i )
    {
        result[i] = result[i - 1];
    }

    result[result_point_index] = '.';
    ++result_length;
    result[result_length] = '';

    // 释放资源
    if ( lhs_point_index )
    {
        free( tmp_lhs ), tmp_lhs = NULL;
    }

    if ( rhs_point_index )
    {
        free( tmp_rhs ), tmp_rhs = NULL;
    }

    return result_length;
}

// 返回结果数值的长度
int big_number_multiply( char *lhs, char *rhs, char *result )
{
    int lhs_start_index = 0, lhs_point_index = 0;
    int rhs_start_index = 0, rhs_point_index = 0;
    int result_is_neg = 0;
    int result_length = 0;

    assert( lhs != NULL && rhs != NULL && result != NULL );
    // 检查数据的合法性
    if ( !(check_logic( lhs, &lhs_start_index )
            && check_logic( rhs, &rhs_start_index )) )
    {
        return -1;
    }

    // 检查数据是否为负数
    result_is_neg = is_neg( lhs, &lhs_start_index );
    if ( is_neg( rhs, &rhs_start_index) )
    {
        result_is_neg = result_is_neg == 1 ?  0 : 1;
    }

    // 检查是否两个数值中存在一个小数或两者都是小数
    if ( !( has_point( lhs, lhs_start_index, &lhs_point_index )
            && has_point( rhs, rhs_start_index, &rhs_point_index ) ) )
    {
        reverse_data( lhs, lhs_start_index, strlen(lhs) );
        reverse_data( rhs, rhs_start_index, strlen(rhs) );
        result_length = compute_value( lhs, lhs_start_index,
                                       rhs, rhs_start_index, result );
        reverse_data( lhs, lhs_start_index, strlen(lhs) );
        reverse_data( rhs, rhs_start_index, strlen(rhs) );
    }
    else // 一个数值中有小数部分
    {
        result_length = compute_decimals(
                          lhs + lhs_start_index, lhs_point_index - lhs_start_index + 1,
                          rhs + rhs_start_index, rhs_point_index - rhs_start_index + 1,
                          result );
    }
    if ( result_is_neg )
        result[result_length++] = '-';
    reverse_data( result, 0, result_length );
    result[result_length] = '';

    return result_length;
}

int main()
{
    char lhs[] = "-1.235";
    char rhs[] = "    3.456";
    char result[40];

    memset( result, '0', sizeof(result) );

    big_number_multiply( lhs, rhs, result );
    printf( "%s
", result );
    return 0;
}

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