[算法 笔记]大数相乘（续）

　　原始版本的大数相乘地址：http://www.cnblogs.com/life91/p/3389890.html

　　在原来的版本中，整数相乘与小数相乘是分开的。其中，在计算小数时，需要将数值与小数点进行分割。在本次版本中，整数和小数在一次计算中进行处理。

本版本中对原始版本中的几个BUG进行处理：

　　1. 小数末尾出现的无效0。例如，”0.123400” -> “0.1234”

　　2. 对于两个均是小于0的小数相乘，需要在结果中的整数部分存放’0’。例如，0.12*0.4 = 0.048

　　参考小数相乘模型：

　　　　2 . 5

　　　× 1 . 2

    ---------------- ---- 数值上标数值表示进位值

          5¹  0            ---- 被乘数中小数点需要滤过

                           ---- 乘数中小数点的计算序列

     2    5

   -----------------

     3¹  0    0             ---- 计算结果中小数点的滤过

 　　在计算过程中，被乘数中出现小数点需要滤过的只是本次计算，再次计算整数位；而乘数需要滤过的是与整个被乘数的计算过程。在结果存放过程中，如果当前位为小数点，则仅仅向前进一位，即将结果存放在整数部分。

　　for ( i = 0; lhs[i] != ''; ++i )
　　    {
　　        int tmp0 = lhs[i] - '0';
　　        res_i = tmp_i;
　　        // 滤过乘数的小数点
　　        if ( lhs[i] == '.' )
　　        {
　　            continue;
　　        }
　　
　　        for ( j = 0; rhs[j] != ''; ++j )
　　        {
　　            int tmp1 = rhs[j] - '0';
　　
　　            // 滤过被乘数的小数点，但是需要记录当前的进位值
　　            if ( rhs[j] == '.' )
　　            {
　　                continue;
　　            }
　　
　　            // 滤过结果中的小数点。
　　            if ( result[res_i] == '.' )
　　                ++res_i;
　　
　　            carry += ( result[res_i] - '0' + tmp0 * tmp1 );
　　            result[res_i++] = carry % 10 + '0';
　　            carry /= 10;
　　        }
　　
　　        while ( carry )
　　        {
　　            if ( result[res_i] == '.' )
　　                ++res_i;
　　
　　            result[res_i++] = carry % 10 + '0';
　　            carry /= 10;
　　        }
　　
　　        // 如果乘数中有小数点，则这个落后于乘数的字符个数。
　　        ++tmp_i;
　　    }

　　如何处理小数末尾部分出现的无效0？在刚刚调用子函数计算的结果中，存放顺序是从低位到高位的。因此，可以首先统计末尾部分的0字符的个数，然后在翻转后的结果中进行截断处理。

　　// 删除小数点后多余的零值
　　    for ( ; zero_cnt < result_point_index && result[zero_cnt] == '0';
　　            ++zero_cnt );
　　
　　// .......
　　
　　// 结果值翻转
　　    reverse_data( result, 0, result_length );
　　    result[result_length - zero_cnt] = '';

 

　　程序的完整源码：

#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;
    }
}

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;
}

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;
}

int compute_value_opt( char *lhs, char *rhs, char *result )
{
    int i = 0, j = 0, res_i = 0;
    int tmp_i = 0;
    int carry = 0;

    assert( lhs != NULL && rhs != NULL && result != NULL );

    for ( i = 0; lhs[i] != ''; ++i )
    {
        int tmp0 = lhs[i] - '0';
        res_i = tmp_i;
        // 滤过乘数的小数点
        if ( lhs[i] == '.' )
        {
            continue;
        }

        for ( j = 0; rhs[j] != ''; ++j )
        {
            int tmp1 = rhs[j] - '0';

            // 滤过被乘数的小数点，但是需要记录当前的进位值
            if ( rhs[j] == '.' )
            {
                continue;
            }

            // 滤过结果中的小数点。
            if ( result[res_i] == '.' )
                ++res_i;

            carry += ( result[res_i] - '0' + tmp0 * tmp1 );
            result[res_i++] = carry % 10 + '0';
            carry /= 10;
        }

        while ( carry )
        {
            if ( result[res_i] == '.' )
                ++res_i;

            result[res_i++] = carry % 10 + '0';
            carry /= 10;
        }

        // 如果乘数中有小数点，则这个落后于乘数的字符个数。
        ++tmp_i;
    }

    result[res_i] = '';

    return res_i;
}

int big_number_multiply_opt( char *lhs, char *rhs, char *result )
{
    int lhs_digit_start = 0, rhs_digit_start = 0;
    int lhs_point_index = 0, rhs_point_index = 0;
    int lhs_len = 0, rhs_len = 0;
    int result_is_neg = 0;
    int result_length = 0;
    int result_point_index = 0;
    int zero_cnt = 0;

    assert( lhs != NULL && rhs != NULL && result != NULL );

    // 检查数据的合法性
    if ( !(check_logic( lhs, &lhs_digit_start )
            && check_logic( rhs, &lhs_digit_start )) )
    {
        return -1;
    }

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

    // 计算结果中，小数点的位置
    has_point( lhs, lhs_digit_start, &lhs_point_index );
    has_point( rhs, rhs_digit_start, &rhs_point_index );
    lhs_len = strlen( lhs );
    rhs_len = strlen( rhs );
    result_point_index =  lhs_len - lhs_point_index
                            + rhs_len - rhs_point_index - 2;
    result[result_point_index] = '.';

    // 计算大数值
    reverse_data( lhs, lhs_digit_start, lhs_len );
    reverse_data( rhs, rhs_digit_start, rhs_len );
    result_length = compute_value_opt( lhs + lhs_digit_start,
                                       rhs + rhs_digit_start, result );
    reverse_data( rhs, rhs_digit_start, rhs_len );
    reverse_data( lhs, lhs_digit_start, lhs_len );

    // 删除小数点后多余的零值
    for ( ; zero_cnt < result_point_index && result[zero_cnt] == '0';
            ++zero_cnt );

    // 需要注意的是，在0.xx与0.xx相乘时，考虑最开始部分需要存在一个0.
    if ( result_length == result_point_index )
    {
        result[result_length++] = '0';
    }

    // 对小数赋值的处理。
    if ( result_is_neg )
        result[result_length++] = '-';

    // 结果值翻转
    reverse_data( result, 0, result_length );
    result[result_length - zero_cnt] = '';

    return result_length - zero_cnt;
}

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

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

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