自己写的高精度除法！当两个数相差较大时效率好低，不知如何修改。

将就看吧，等以后进修后有能力时再改出高效率版！

 

#include "stdio.h"
#include "string.h"
#define DIGIT 300

int Compare(int *dividend, int *divsor, int dividendlen, int divsorLen);
int Cal(int *dividend, int *divsor, int dividendlen, int divsorLen);
static int iResult;

int main(void)
{
    int iDividend[DIGIT] = {0};
    int iDivsor[DIGIT] = {0};
    char cDividendTemp[DIGIT];
    char cDivsorTemp[DIGIT];
    int iDividendLength, iDivsorLength;
    int i, j, k;
    int flag;

    while(scanf("%s %s", cDividendTemp, cDivsorTemp) != EOF)
    {
        iResult = 0;
        iDividendLength = strlen(cDividendTemp);
        iDivsorLength = strlen(cDivsorTemp);
       
        for (i = 0; i < iDividendLength; ++i)
        {
            iDividend[i] = cDividendTemp[i] - '0';
        }
       
        for (j = 0; j < iDivsorLength; ++j)
        {
            iDivsor[j] = cDivsorTemp[j] - '0';
        }
       
        flag = Compare(iDividend, iDivsor, iDividendLength, iDivsorLength);
        //当两数相等，结果直接给出
        if (flag == 2)
        {
            printf ("%d %d/n", 1, 0);
        }
        else if (flag == 1)   //被除数小于除数商位0，余数位被除数
        {
            printf ("%d ", 0);
           
            for (k = 0; k < iDividendLength; ++k)
            {
                printf ("%d", iDividend[k]);
            }
           
            printf ("/n");
        }
        else
        {
            int len = Cal(iDividend, iDivsor, iDividendLength, iDivsorLength);
           
            printf("%d ", iResult);
           
            for (int x = 0; x < len; ++x)
            {
                printf("%d", iDividend[x]);
            }

            printf("/n");
        }
    }
    return 0;
}
//比较两数的大小
int Compare(int *dividend, int *divsor, int dividendlen, int divsorlen)
{
    if (dividendlen > divsorlen)
    {
        return 0;
    }
    else if (dividendlen < divsorlen)
    {
        return 1;
    }
    else if (dividendlen == divsorlen)
    {
        int i;

        for (i = 0; i < divsorlen; ++i)
        {
            if (dividend[i] > divsor[i])
            {
                return 0;
            }
            else if (dividend[i] < divsor[i])
            {
                return 1;
            }
        }
    }

    return 2;
}
//进行减法运算从而实现除法运算
int Cal(int *dividend, int *divsor, int dividendlen, int divsorlen)
{
    int i;  //用于循环控制中的临时变量
    int j;   
    int k;
    int l;
    int m, n, x, y;
    int prelen = dividendlen;  //存储变化前的长度
    int dlen = dividendlen;        //变化后的长度
    int flag = 0;                //用于标识两个数的大小 0:被除数大于除数 1除数大于被除数 2两数相等
   
    while (flag == 0)
    {
        k = 0;
        //正常的减法运算过程，本为不够向高位借1
        for (i = divsorlen - 1, j = dlen - 1 ; i >= 0; --i, --j)
        {
            if (dividend[j] < divsor[i])
            {
                dividend[j - 1] -= 1;
                dividend[j] = dividend[j] - divsor[i] + 10;
            }
            else if (dividend[j] >= divsor[i])
            {
                dividend[j] -= divsor[i];
            }
            //将负数值修正
            for (l = 1; l < dlen - divsorlen; ++l)
            {
                if (dividend[l] < 0)
                {
                    dividend[l] += 10;
                    dividend[l - 1] -= 1;
                }
            }
        }
       
        prelen = dlen;

        while (dividend[k] == 0)
        {
            ++k;
            --dlen;
        }
       
        if (prelen != dlen && dlen != 0)
        {
            for (m = k, n = 0; m < prelen; ++m, ++n)
            {
                dividend[n] = dividend[m];
            }

            for (x = dlen; x < prelen; ++x)
            {
                dividend[x] = 0;
            }
        }
       
        flag = Compare(dividend, divsor, dlen, divsorlen);

        ++iResult;
    }
    //当最后一次检测两个数的大小关系时两数相等则证明，可以整除
    if (flag == 2)
    {
        for (y = 0; y < dlen; ++y)
        {
            dividend[y] = 0;
        }
       
        dlen = 1;
        ++iResult;
    }

    return dlen;
}