[算法 筆記]大數相乘

　　今天去參加騰訊筆試，其中有一道選答題：大數相乘問題。在編寫代碼的過程，我突然發現以前寫的原始的大數相乘是一個很簡陋的源碼。所以，下午找個時間重新寫了一份。

　　大數相乘：兩個超出整型限制的兩個數相乘，例如，兩個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] != '\0'; ++i, ++tmp_i )
    {
        res_i = tmp_i;  // 在每次計算時，結果存儲的位需要增加。如上述模擬過程中，第二行。 12         carry = 0;

        for ( j = rhs_start_index; rhs[j] != '\0'; ++j )
        {
            int tmp_lhs = lhs[i] - '0';
            int tmp_rhs = rhs[j] - '0';
            carry += ( result[res_i] - '0' );       // 這里需要注意，因為每次計算並不能保證以前計算結果的進位都消除，因此這里是加號。 19             carry += ( tmp_lhs * tmp_rhs );　　　　  // 並且以前的計算結果也需要考慮。 20             result[res_i++] = ( carry % 10 + '0' );
            carry /= 10;
        }

        while ( carry )　　// 當乘數的一次計算完成，可能存在有的進位沒有處理。因此，這里對其進行處理。 25         {
            result[res_i++] = ( carry % 10 + '0' );
            carry /= 10;
        }
    }
    result[res_i] = '\0';

    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(' ', '\n'), isspace() return 0. */
    for ( ; isspace( data[start] )!= 0
            && data[start] != '\0'; ++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] != '\0'; ++start )
    {
        if ( isdigit( data[start] ) || data[start] == '.' )
        {
            // 判斷數據為小數的格式是否正確。
            if ( data[start] == '.' && point_cnt == 0 )
            {
                ++point_cnt;
            }
            else if ( point_cnt > 1 )
            {
                break;
            }
        }
    }

    // 若小數點后面無數據，則不合法
    if ( data[start] != '\0' )
    {
        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] != '\0'; ++i, ++tmp_i )
    {
        res_i = tmp_i;
        carry = 0;

        for ( j = rhs_start_index; rhs[j] != '\0'; ++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] = '\0';

    return res_i;
}

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

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

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

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 != '\0' )
    {
        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] = '\0';
    }
    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] = '\0';
    }
    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] = '\0';

    // 釋放資源
    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] = '\0';

    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\n", result );
    return 0;
}

 

　　這里我僅僅提供了一個簡單的測試，歡迎大家來指導！！