大整数运算

大整数的储存

为了方便随时获取大整数的长度，一般都会定义一个int型变量len来记录其长度，并和d数组组成结构体。

struct bign{
	int d[1000];
	int len;
	bign(){  //初始化结构体
		memset(d, 0, sizeof(d));  //fill(d, d + sizeof(d), 0)
		len = 0;
	}
};

在输入大整数时，一般都是先用字符串进行读入，然后再把字符串另存为到bign结构体，由于按照字符串的顺序进行读入时，整数的高位就会变成数组的低位，所以要将字符串倒着赋给d[]数组。

bign change(char str[]){  //将整数转换为bign
	bign a;
	a.len = strlen(str);
	for (int i = 0; i < a.len; i++){
		a.d[i] = str[a.len - i - 1] - '0';
	}
	return a;
}

输出bign

void print(bign a){
    for(int i=a.len-1;i>=0;i--){
        printf("%d",a.d[i]);
    }
}

大整数的比较

规则：先判断两者的len大小，如果不相等，则以长的为大；如果相等，则从高位到低位进行比较，直到出现某一位不等，只要有一位a大，则a大，只要有一位a小，则a小。

int compare(bign a, bign b){
    if (a.len > b.len) return 1;
    else if (a.len < b.len) return -1;
    else{
        for (int i = a.len - 1; i >= 0; i--){  //从高位往低位比较
            if (a.d[i] > b.d[i]) return 1;
            else if (a.d[i] < b.d[i]) return -1;
        }
        return 0;
    }
}

大整数的四则运算

1. 高精度加法

思路：与整数相加的方法一样，将改为上的两个数字与进位相加，得到的结果取个位数作为该位结果，取十位数作为新的进位。

bign add(bign a, bign b){
    bign c;
    int ci = 0;  //进位
    for (int i = 0; i < a.len || i < b.len; i++){	//以较长的为界限
        int temp = a.d[i] + b.d[i] + ci;
        c.d[c.len++] = temp % 10;
        ci = temp / 10;
    }
    if (ci != 0){
        c.d[c.len++] = ci;
    }
    return c;
}

\(\color{red}{最后指出，这样写法的条件是两个对象都是非负整数。如果有一方是负的，可以在转换到数组这一步时去掉其负号，然后采用高精度减法；如果两个都是负的，就都去掉负号}\)
\(\color{red}{后采用高精度加法，最后再把负号加回去即可。}\)

2. 高精度减法

思路：对于某一步，比较被减位和减位，如果不够减，则令被减位的高位减1、被减位加10再进行减法；如果够减，就直接减。最后一步要注意减法后高位可能有多余的0，要去除它们，但也要保证结果至少有一位数。

bign sub(bign a, bign b){
    bign c;
    for (int i = 0; i < a.len || i < b.len; i++){  //以较长的为界限
        if (a.d[i] < b.d[i]){
            a.d[i + 1]--;
            a.d[i] += 10;
        }
        c.d[c.len++] = a.d[i] - b.d[i];
    }
    while (c.len > 1 && c.d[c.len - 1] == 0){
        c.len--;
    }
    return c;
}

\(\color{red}{最后需要指出，使用sub函数前要比较两个数的大小，如果被减数小于减数，需要交换两个变量，然后输出负号，再使用sub函数。}\)

3. 高精度与低精度的乘法

思路：取bign的某位与int型整体相乘，再与进位相加，所得结果的个位数作为该位结果，高位部分作为新的进位。

bign multi(bign a, int b){
	bign c;
	int ci = 0;  //进位
	for (int i = 0; i < a.len; i++){
		int temp = a.d[i] * b + ci;
		c.d[c.len++] = temp % 10;
		ci = temp / 10;
	}
	while (ci != 0){
		c.d[c.len++] = ci % 10;
		ci /= 10;
	}
	return c;
}

\(\color{red}{另外，如果a和b中存在负数，需要先记录下其负号，然后取他们的绝对值代入函数。}\)

3. 高精度与低精度的除法

思路：对于某一步来说，上一步的余数乘以10加上该步的位，得到该步临时的被除数，将其与除数比较：如果不够除，则该位的商为0；如果够除，则商即为对应的商，余数即为对应的余数。最后一步要注意减法后高位可能有多余的0，要去除它们，但也要保证结果至少有一位数。

bign divide(bign a, int b, int &r){	//r为余数
	bign c;
	c.len = a.len;
	for (int i = a.len - 1; i >= 0; i--){
		r = r * 10 + a.d[i];
		if (r < b) c.d[i] = 0;
		else{
			c.d[i] = r / b;
			r = r % b;
		}
	}
	while (c.len > 1 && c.d[c.len - 1] == 0){
		c.len--;
	}
	return c;
}

在上述代码中，考虑到函数每次只能返回一个数据，而很多题目里面会经常要求得到余数，因此把余数写成“引用”的形式直接作为参数传入，或是把r设成全局变量。其作用是在函数中可以视为直接对原变量进行修改，而不像普通函数参数那样，在函数中的修改不影响原变量的值。这样当函数结束时，r的值就是最终的余数。