Linux C/C++ 编程练手 --- 大数相加和大数相乘

最近写了一个大数相乘和相加的程序，结果看起来是对的。不过期间的效率可能不是最好的，有些地方也是临时为了解决问题而直接写出来的。

可以大概说一下相乘和相加的解决思路（当然，大数操作基本就是两个字符串的操作了）：

一、思路：

在操作大数前，一定会有一些异常判断，比如输入的字符串是否合法（是否是纯数字？是否为空？等等），然后才是具体的操作实现：

1、大数相加（大体思路：将大数相加问题，转换成十以内的两数相加）：

①申请合适的空间，一般可以认定，两个数字相加时，长度至多是最长的数的长度或最长的数的长度加1；

②从个位（字符串中就是从最后一位）开始，进行逐位相加；

③每位相加后，立即判断是否有进位，再将本次计算的个位数字记录到result字符串中；

④当短字符串过完后，按照同样的方式，过完长字符串的剩余数字；

⑤长字符串过完后，判断是否存在进位，如果有，则最后再赋值到result字符串中，如果没有，则最后将0（也就是结束符）赋值到result字符串中；

⑥由于操作的result字符串是倒置操作的，最后再把字符串逆置，返回即为两数相加结果；

2、大数相乘（大体思路：将大数相乘问题，转换成十以内的两数相乘）：

①按照一般的两数相乘的思路，运算过程中，会产生一个二维数组样式的中间结果（准确点是一个字符串数组），数组的行数是第二个数字的个数；

②每次得出这个字符串数组的一行的结果，具体为：

a、针对这个字符串数组，每次运算前，申请合适的空间，一般可以认定，一个数和一个十以内的数字相乘时，长度至多是该数的长度或该数长度加1；但是还有一点需要考虑到，从十位开始，数字相乘后，默认是在最后加0的，规律为十位对应1个0，百位对应2个0，以此类推。因此需要申请的空间除了该数的长度加1外，还需要加上本次操作需要额外增加的0的个数；

b、在数字真正相乘前，需要将对应的0进行补齐（即个位数相乘时增加0个0，十位数相乘时增加1个0 ... ... ）

c、每次取出第二个数的一个数字，取出顺序为倒序（从个位开始），然后与第一个数字进行逐位相乘；

d、相乘结果判断进位，并且保存，此次乘出来的结果保留个位数字，放入到本行的字符串结果中；

e、过完第一个数字的长度后，判断是否有进位，有的话则直接将进位赋值到本行字符串结果中，没有的话则将0赋值到本行字符串结果中；

f、然后循环进行，直到将第二个数字过完后，就会产出一个二维数组（或称之为字符串数组）；

③最后把这个字符串数组的每一行相加（用到上面的大数相加函数来做），就是最终的相乘结果；

二、代码：

1、大数相加：

 

char *BigNumSum(char *bignum1, char *bignum2)

{

        char *result, *big, *small;

        int bignum1_length = strlen(bignum1);

        int bignum2_length = strlen(bignum2);

        int bigger, smaller;



        if(bignum1_length >= bignum2_length)

        {

                bigger = bignum1_length;

                smaller = bignum2_length;

                big = bignum1;

                small = bignum2;

        }

        else

        {

                bigger = bignum2_length;

                smaller = bignum1_length;

                big = bignum2;

                small = bignum1;

        }



        int tmp, tmp_gewei, tmp_jinwei = 0, num = 0;

        result = (char *)malloc(sizeof(char) * (bigger + 1));

        for(int i = smaller - 1, j = bigger - 1; i >= 0 && j >= 0; i--, j--)

        {

                char *tmp_big = ctocs(big[j]);

                char *tmp_small = ctocs(small[i]);

                tmp = atoi(tmp_big) + atoi(tmp_small) + tmp_jinwei;

                tmp_gewei = tmp % 10;

                tmp_jinwei = tmp / 10;

                result[num++] = tmp_gewei + ASICNUM;

        }

        for(int i = bigger - smaller - 1; i >= 0; i--)

        {

                char *tmp_big = ctocs(big[i]);

                tmp = atoi(tmp_big) + tmp_jinwei;

                tmp_gewei = tmp % 10;

                tmp_jinwei = tmp / 10;

                result[num++] = tmp_gewei + ASICNUM;

        }

        if(tmp_jinwei > 0)

        {

                result[num] = tmp_jinwei + ASICNUM;

        }

        else

        {

                result[num] = 0;

        }

        recover(result);

        return result;

}

 

2、大数相乘：

 

char *BigNumMultip(char *bignum1, char *bignum2)

{

        char *result;

        int bignum1_length = strlen(bignum1);

        int bignum2_length = strlen(bignum2);



        char *tmp[bignum2_length];

        int i;

        for(i = bignum2_length - 1; i >= 0; i--)

        {

                int t;

                int j;

                tmp[i] = (char *)malloc(sizeof(char) * (bignum1_length + 1 + (bignum2_length -1 - i)));

                for(t = 0; t < bignum2_length -1 - i; t++)

                        tmp[i][t] = 0 + ASICNUM;

                int tmp_jinwei = 0;

                for(j = bignum1_length - 1; j >= 0; j--)

                {

                        char *tmp_bignum1 = ctocs(bignum1[j]);

                        char *tmp_bignum2 = ctocs(bignum2[i]);

                        int tmp_multip = atoi(tmp_bignum1) * atoi(tmp_bignum2) + tmp_jinwei;

                        int tmp_gewei = tmp_multip % 10;

                        tmp_jinwei = tmp_multip / 10;

                        tmp[i][t++] = tmp_gewei + ASICNUM;

                }

                if(tmp_jinwei > 0)

                {

                        tmp[i][t] = tmp_jinwei + ASICNUM;

                }

                else

                {

                        tmp[i][t] = 0;

                }

                recover(tmp[i]);

//              puts(tmp[i]);

        }

        result = (char *)malloc(sizeof(char) * (strlen(tmp[i+1]) + 1));

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

        for(int i = 0; i < bignum2_length; i++)

        {

                result = BigNumSum(tmp[i], result);

        }

        

        return result;

}

3、其他：

①字符串逆置：

 

void recover(char *string)

{

        int length = strlen(string);

        int tmp;

        for(int i = 0; i < length / 2; i++)

        {

                tmp = string[i];

                string[i] = string[length - i - 1];

                string[length - i - 1] = tmp;

        }

}

②判断是否是数字字符串：

 

bool isDigital(char *string)

{

        bool ret = true;

        int length = strlen(string);



        for(int i = 0; i < length; i++)

        {

                if(string[i] < '0' || string[i] > '9')

                {

                        ret = false;

                        break;

                }               

        }

        return ret;

}

③字符转换为字符串：

 

char *ctocs(char ch)

{

        char *a;

        a = (char *)malloc(sizeof(char) * 2);

        a[0] = ch;

        a[1] = 0;



        return a;

}

④main函数调用：

 

int main(int argc, char **argv)

{

        if(3 != argc)

        {

                printf("error\n");

                return 1;

        }

        char *bignum1 = argv[1];

        char *bignum2 = argv[2];



        bool ret1 = isDigital(bignum1);

        bool ret2 = isDigital(bignum2);



        if(false == ret1 || false == ret2)

        {

                printf("input not number\n");

                return 2;

        }

        char *multip_result = BigNumMultip(bignum1, bignum2);

        char *sum_result = BigNumSum(bignum1, bignum2);



        printf("数字 1：%s\n数字 2：%s\n两数积：%s\n两数和：%s\n", bignum1, bignum2, multip_result, sum_result);

        return 0;

}

这段代码也就是按照一个最基本的思路进行简单的实现，基本如上，没有太多注释，目前可以预见到的问题就是：①执行效率、②内存消耗；后面有空会再进行优化的~

目前测试了一些数字，是可以正确返回的（当然，太大的数字也就是验证的后面或前面的几位的数字）。如果大家有发现不对有有问题的地方，求指点~