两无限大数相加减C语言程序

#include 
#include 
#include 
#include 

#define MAXNUM 1000000000000000000

//存储数据用的结构
//long int型指针（Number）指向一个long int 数组，索引值最底的位，
//为10进制数的最低18位。依次类推。
//int型数值（Length）为数组的长度。
//因为数组长度受int型最大值的限制，所以这个算法也不能真正实现“无限”。

typedef struct 
{
    __int64* Number;
    int Length;
}BigInt;



typedef struct node
{
    int num;

    struct node *next;

    struct node *prev;

} node;


typedef struct 
{
    int* Number;
    int Length;
}BigData;

void PrintBigInt(BigInt* bigNumber);

__int64 pow(int x, int y);

BigInt* MakeBigIntFromString(char* bigIntString);

void DeleteBigInt(BigInt* bigNumber);

BigInt* Add2BigInt(BigInt* n1, BigInt* n2);


void main()
{
	BigInt* result;
	double tstart, tend, tcost;
    char* numberStr = "111111111111111111111111\0";
    char* numberStr2 = "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111\0";
    BigInt* bn = MakeBigIntFromString(numberStr);
    BigInt* bn2 = MakeBigIntFromString(numberStr2);
    
    tstart = clock();
    PrintBigInt(bn);
    PrintBigInt(bn2);
    
        result = Add2BigInt(bn, bn2);
        PrintBigInt(result);
        DeleteBigInt(result);
    
    DeleteBigInt(bn);
    DeleteBigInt(bn2);
    tend = clock();
    tcost = (double)(tend - tstart) / CLOCKS_PER_SEC;
    printf("%lf\n", tcost);
}

BigInt* Add2BigInt(BigInt* n1, BigInt* n2)
{
	int i;
	BigInt* nOut;
    int maxLength = n1->Length < n2->Length ? n2->Length : n1->Length;

    //加法只可能产生1位的进位，所以，只需要创建一个和最大长度相同的。
    
    nOut = (BigInt*)malloc(sizeof(BigInt));
    nOut->Length = maxLength;
    nOut->Number = (__int64*)malloc(sizeof(__int64)* nOut->Length);
    for (i = 0; i < nOut->Length; i++)
	{
        nOut->Number[i] = 0;
    }
    for (i = 0; i < nOut->Length; i++)
	{
        if (n1->Length > i)
		{
            nOut->Number[i] += n1->Number[i];
        }
        if (n2->Length > i)
		{
            nOut->Number[i] += n2->Number[i];
        }

        
       // 处理进位。最高位不需要处理。
        
        if (i != (nOut->Length - 1))
		{
            if (nOut->Number[i] >= MAXNUM)
			{
                nOut->Number[i] -= MAXNUM;
                nOut->Number[i + 1] = 1;
            }
        }
    }

    return nOut;

}


//两数相减
BigInt* Del2BigInt(BigInt* n1, BigInt* n2)
{
	int i;
	BigInt* nOut;
    int maxLength = n1->Length < n2->Length ? n2->Length : n1->Length;
	int minLength = n1->Length > n2->Length ? n2->Length : n1->Length;

    //加法只可能产生1位的进位，所以，只需要创建一个和最大长度相同的。
    
    nOut = (BigInt*)malloc(sizeof(BigInt));
    nOut->Length = maxLength;
    nOut->Number = (__int64*)malloc(sizeof(__int64)* nOut->Length);
    for (i = 0; i < nOut->Length; i++){
        nOut->Number[i] = 0;
    }
	//先默认第一个数大
    for (i = 0; i < nOut->Length; i++)
	{
		if(n1->Number[i] >= n2->Number[i])
		{
			nOut->Number[i]=n1->Number[i] - n2->Number[i];
		}
		else
		{
			nOut->Number[i]=n1->Number[i]+MAXNUM - n2->Number[i];
			n1->Number[i+1] -=1;
		}


        if (n1->Length > i)
		{
            nOut->Number[i] += n1->Number[i];
        }
        if (n2->Length > i)
		{
            nOut->Number[i] += n2->Number[i];
        }

        
       // 处理进位。最高位不需要处理。
        
        if (i != (nOut->Length - 1))
		{
            if (nOut->Number[i] >= MAXNUM)
			{
                nOut->Number[i] -= MAXNUM;
                nOut->Number[i + 1] = 1;
            }
        }
    }

    return nOut;

}

//从高到低显示数值
//不考虑单个__int64数据超出18位的情况。

void PrintBigInt(BigInt* bigNumber){
	int i;
	int length;
    if (bigNumber == NULL){
        return;
    }
    if (bigNumber->Length < 1){
        return;
    }
    length = bigNumber->Length - 1;
    for (i = length; i >= 0; i--)
	{
        if (i != length)
		{
            if (bigNumber->Number[i] == 0){
                printf("000000000000000000");
            }
            else{
                printf("%018I64d", bigNumber->Number[i]);
            }
        }
        else{
            if ((*bigNumber).Number[i] != 0){
                printf("%I64d", bigNumber->Number[i]);
            }
        }
    }
    printf("\n");

}


//把字符串表示的数值格式化为BigInt型的结构
//字符串结束位置用\0表示。

BigInt* MakeBigIntFromString(char* bigIntString){
	int powNum = 0;
    int numPos = 0;
	int i;
    //获取字符串长度
    int cLength = strlen(bigIntString);
    BigInt* outBigInt = (BigInt*)malloc(sizeof(BigInt));
    if (cLength % 18 != 0){
        outBigInt->Length = cLength / 18 + 1;
    }
    else{
        outBigInt->Length = cLength / 18;
    }
    if (outBigInt->Length == 0)
	{
        outBigInt->Length = 1;
        outBigInt->Number = (__int64 *)malloc(sizeof(__int64));
        outBigInt->Number[0] = 0;

        return outBigInt;
    }
    outBigInt->Number = (__int64 *)malloc(sizeof(__int64)* outBigInt->Length);
    for (i = 0; i < outBigInt->Length; i++){
        outBigInt->Number[i] = 0;
    }
    for (i = cLength - 1; i >= 0; i--){
        powNum = (cLength - 1 - i) % 18;
        numPos = (cLength - 1 - i) / 18;
        outBigInt->Number[numPos] += (bigIntString[i] - 48) * pow(10, powNum);
    }

    return outBigInt;
}



/*
BigData* MakeBigIntFromString(char* bigIntString){
	int powNum = 0;
    int numPos = 0;
	int i;
    //获取字符串长度
    int cLength = strlen(bigIntString);
    BigData* outBigInt = (BigData*)malloc(sizeof(BigData));
    if (cLength % 4 != 0){
        outBigInt->Length = cLength / 4 + 1;
    }
    else{
        outBigInt->Length = cLength / 4;
    }
    if (outBigInt->Length == 0)
	{
        outBigInt->Length = 1;
        outBigInt->Number = (node *)malloc(sizeof(node));
        outBigInt->Number->num = 0;

        return outBigInt;
    }
    outBigInt->Number = (__int64 *)malloc(sizeof(__int64)* outBigInt->Length);
    for (i = 0; i < outBigInt->Length; i++){
        outBigInt->Number[i] = 0;
    }
    for (i = cLength - 1; i >= 0; i--){
        powNum = (cLength - 1 - i) % 18;
        numPos = (cLength - 1 - i) / 18;
        outBigInt->Number[numPos] += (bigIntString[i] - 48) * pow(10, powNum);
    }

    return outBigInt;
}


*/

//简单的幂函数
//x y 都必须为正整数

__int64 pow(int x, int y)
{
	int i;
	__int64 outNum = x;
    if (x == 0 || x < 0 || y < 0){
        return 0;
    }
    if (x == 1 || y == 0){
        return 1;
    }

    for (i = 1; i < y; i++){
        outNum = outNum * x;
    }

    return outNum;
}

void DeleteBigInt(BigInt* bigNumber){
    if (bigNumber != NULL){
        if (bigNumber->Number != NULL){
            free(bigNumber->Number);
        }
        free(bigNumber);
    }
}
/*int main()
{
	__int64 a;
	a=999999999999999999;
	printf("%I64d",a);
	printf("Input num%d",sizeof(__int64));

}*/