大整数加减乘除 c实现

最近准备一下笔试，发现自己的算法方面的编程有点弱鸡，菜的抠脚。前几天做了腾讯的一个笔试模拟，需要实现的是大整数的乘法，于是乎就想着把加减乘除都实现了。网上也参考过，主要给思路和坑。

最主要的

既然是大整数，那么一定是数组存储，不可能是long等。
使用字符char可以完成计算，但要减去’0’
之后要加回来

加法

分配一个比两个加数大1位的字符串数组，作为返回
使用加数中位数少进行加，注意不要越界，另一个加数直接加到结果上面
最后对结果进行清除首位可能的0

减法

分配被减数位数的字符串数组作为返回
减数位数循环，最主要的是注意借位！
被减数剩下的直接赋予结果
注意100-100=0 而不是000

乘法

对应位数相乘，注意进位，相对简单一些
首位可能清零

除法

最麻烦的除法来了，除法中存在除数，被除数，余数，商。除数可能为0
余数是5而不是05之类的
商也是5而不是005之类
除法的思想主要是我们小时候画的除法“厂”一位一位除，其中注意循环条件在跳至最后一位结束，然后余数继续加被除数的剩余位数，继续做除法。

while（被除数指针越界）
{
    "余数"+"被除数对应位" > "除数" 时
    除法，得到商和余数
    商存储
    余数继续参与循环
}

废话不多说了，这里应该还有一种保留多少位小数的要求，这里你可以得到商和余数后继续加入循环，如果保留6位小数，那么你在余数末尾加7个0，保证最后四舍五入。这个没有实现，有兴趣的你们可以试试。在写代码时我也很晕，所以用了goto条件，希望你能指点哈~~

代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAXINT 1000

char *fun_cal(char *a,char *b)
{
    int size_a = strlen(a);
    int size_b = strlen(b);
    int size_res = size_a + size_b;
    char *result = malloc((size_res+1)*sizeof(char));
    memset(result,0,(size_res + 1));

    int i=size_a-1;
    int j=size_b-1;
    for(i;i>=0;i--)
    {
        for(j=size_b-1;j>=0;j--)
        {
            int k = i+j+1;
            result[k] += (a[i] - '0') * (b[j] - '0');
            if (result[k] >= 10)
            {
                result[k-1] += result[k]/10;
                result[k] %= 10;
            }
        }
    }

    int flag = result[0] == 0 ?1:0;
    i=0;
    for(i;i<size_res-flag;i++)
        result[i] = result[i+flag] + '0';

    result[size_res-flag] = '\0';
    return result;
}


int compare(char *a,char *b)
{
    int size_a = strlen(a);
    int size_b = strlen(b);
    if (size_a > size_b)
    {
        return 1;
    }
    else if (size_a < size_b)
    {
        return -1;
    }
    else 
    {
        int p = 0;
        while(p < size_a)
        {
            if (a[p] > b[p])
            {
                return 1;
            }
            else if (a[p] < b[p])
            {
                return -1;
            }
            else
                p++;
        }
        return 0;
    }
}


void fun_clean_zero(char *str)
{
    int flag = 0,i;
    while(str[0] == '0' && strlen(str) > 1)
    {
        int size_res = strlen(str);
        flag = 1;
        for(i=0;i<size_res-flag;i++)
            str[i] = str[i+flag] ;
        str[size_res-flag] = '\0';
    }
}

char *fun_dec(char *a,char *b)
{
    int size_b = strlen(b);
    int size_a = strlen(a);
    int size_res = size_a > size_b ? size_a : size_b;
    char *result = malloc((size_res+1)*sizeof(char));
    memset(result,0,(size_res));



    int i = 1;
    for(i;i<=size_a;i++)
    {
        if (b[size_b-i]<a[size_a-i])
        {
            result[size_res-i] = (b[size_b-i] - '0' +10)-(a[size_a-i] - '0');
            int j=1;
            while((i+j) <= size_b)
            {
                if (b[size_b-i-j] > '0')
                {
                    b[size_b-i-j] --;
                    for(--j;j>0;j--)
                    {
                        b[size_b-i-j] += 9;
                    }
                    break;
                }
                j++;
            }

        }
        else
            result[size_res-i] = (b[size_b-i] - '0')-(a[size_a-i] - '0');
    }

    for (i = size_a+1; i <= size_b; ++i)
    {
        result[size_res-i] = (b[size_b-i] - '0');
    }

    // do
    // {
    //  int flag = 0;
    //  printf("once\n");
    //  if (result[0] == 0 )
    //  {
    //      flag = 1;
    //  }
    //  int j;
    //  printf("flag %d\n",flag);
    //  for(j=0;j<size_res;j++)
    //  {
    //      result[j] = result[j+flag];
    //  }
    //  result[size_res-flag] = '\0';
    //  printf("len is %d\n",strlen(result) );
    // }while(result[0] == 0 && strlen(result)>1);  

    // i=0;
    // for(i;i<strlen(result);i++)
    //  result[i] = result[i] + '0';

    int flag = result[0] == 0 ?1:0;
    i=0;
    for(i;i<size_res-flag;i++)
        result[i] = result[i+flag] + '0';

    result[size_res-flag] = '\0';
    // while(result[0] == '0' && strlen(result) > 1)
    // {
    //  printf("once \n");
    //  flag = 1;
    //  for(i=0;i<size_res-flag;i++)
    //      result[i] = result[i+flag] ;
    //  result[size_res-flag] = '\0';
    // }
    // printf("len is %d\n",strlen(result) );
    fun_clean_zero(result);

    return result;
}



int fun_div(char *a,char *b,char *c,char *d)
{
    if (compare(b,"0") == 0)
    {
        printf("b is zero\n");
        return -1;
    }
    int size_a = strlen(a);

    int i=0;
    char *tmp = malloc(1000*sizeof(char));
    memset(tmp,0,1000);

    while(i <= size_a)
    {
        while(compare(tmp,b) < 0)
        {
            memcpy(tmp+strlen(tmp),a+i,1);
            if (c[i] == 0)
            {
                c[i]='0';
            }
            i++;
            if (i > size_a)
            {
                goto end;
            }
        }

        int j=0;
        char jj[5];
        sprintf(jj,"%d", j);
        while(compare(tmp,fun_cal(jj,b))>0 )
        {
            j++;
            sprintf(jj,"%d", j);
        }

        if (compare(tmp,fun_cal(jj,b)) == 0)
        {
            sprintf(jj,"%d", j);
        }
        else
        {
            sprintf(jj,"%d", j-1);
        }           
        c[i] = jj[0];

        tmp = fun_dec(fun_cal(jj,b),tmp);

        if (compare(tmp,"0") == 0)
        {
            memset(tmp,0,1000);
        }
    }

end:
    fun_clean_zero(c);
    if (strlen(tmp) == 0)
    {
        memcpy(d,"0",1);
    }
    else
        memcpy(d,tmp,strlen(tmp));
    return 0;

}

char * fun_sum(char *a, char *b)
{
    int size_b = strlen(b);
    int size_a = strlen(a);
    int size_res = size_a > size_b ? size_a : size_b;
    size_res++;
    char *result = malloc((size_res+2)*sizeof(char));
    memset(result,0,(size_res));

    int i = 1;
    for(i;i<=size_a;i++)
    {
        result[size_res-i] = (a[size_a-i] - '0') + (b[size_b-i] - '0') + result[size_res-i];
        if (result[size_res-i] >= 10)
        {
            result[size_res-i] %=10;
            result[size_res-i-1] +=1;
        }
    }

    for (i = size_a+1; i <= size_b; ++i)
    {
        result[size_res-i] += (b[size_b-i] - '0');
        if (result[size_res-i] >= 10)
        {
            result[size_res-i] %=10;
            result[size_res-i-1] +=1;
        }
    }

    int flag = result[0] == 0?1:0;
    int j;
    for(j=0;j<size_res;j++)
    {
        result[j] = result[j+flag] + '0';
    }

    result[size_res-flag] = '\0';
    return result;
}


int main(int argc, char const *argv[])
{
    char *a = malloc(1000*sizeof(char));
    char *b = malloc(1000*sizeof(char));
    char *c ,*d;
    scanf("%s%s",a,b);
    int size_b = strlen(b);
    int size_a = strlen(a);
    // int size_res = size_a > size_b ? size_a : size_b;
    // char *result = malloc((size_res+1)*sizeof(char));
    // memset(result,0,(size_res));
    c = malloc((size_a+1)*sizeof(char));
    memset(c,0,size_a);
    d = malloc((size_a+1)*sizeof(char));
    memset(d,0,size_a);

    /*
    dec
    */
    // result = fun_dec(a,b);
    // printf("result is %s\n",result );

    /*
    div
    */
    int ret = fun_div(a,b,c,d);
    printf("d id %s c is %s\n",d,c );

    /*
    sum
    */
    // result = fun_sum(a,b);
    // printf("result is %s\n",result );
    // return 0;

    /*
    cal
    */
    // result = fun_cal(a,b);
    // printf("result is %s\n",result );


    return 0;
}