前一段时间,小灰发布了一篇有关大整数相加的漫画,没看过的小伙伴可以先看一看:
那么,大整数相乘又是如何实现的呢?
起初,小灰认为只要按照大整数相加的思路稍微做一下变形,就可以轻松实现大整数相乘。但是随着深入的学习,小灰才发现事情并没有那么简单......
————— 第二天 —————
怎样列出这个乘法竖式呢?以 93281 X 2034 为例,竖式如下:
在程序中,我们可以利用int型数组,把两个大整数按位进行存储,再把数组中的元素像小学竖式那样逐个进行计算。
这个乘法竖式的计算过程可以大体分为两步:
1.整数B的每一个数位和整数A所有数位依次相乘,得到中间结果。
2.所有中间结果相加,得到最终结果。
-
/**
-
* 大整数求乘积
-
* @param bigNumberA 大整数A
-
* @param bigNumberB 大整数B
-
*/
-
public static String multiply(String bigNumberA, String bigNumberB) {
-
//1.把两个大整数用数组逆序存储,数组长度等于两整数长度之和
-
int lengthA = bigNumberA.length();
-
int lengthB = bigNumberB.length();
-
int[] arrayA = new int[lengthA];
-
for(int i=0; i< lengthA; i++){
-
arrayA[i] = bigNumberA.charAt(lengthA-1-i) - '0';
-
}
-
int[] arrayB = new int[lengthB];
-
for(int i=0; i< lengthB; i++){
-
arrayB[i] = bigNumberB.charAt(lengthB-1-i) - '0';
-
}
-
//2.构建result数组,数组长度等于两整数长度之和
-
int[] result = new int[lengthA+lengthB];
-
//3.嵌套循环,整数B的每一位依次和整数A的所有数位相乘,并把结果累加
-
for(int i=0;i<lengthB;i++) {
-
for(int j=0;j<lengthA;j++) {
-
//整数B的某一位和整数A的某一位相乘
-
result[i+j] += arrayB[i]*arrayA[j];
-
//如果result某一位大于10,则进位,进位数量是该位除以10的商
-
if(result[i+j] >= 10){
-
result[i+j+1] += result[i+j]/10;
-
result[i+j] = result[i+j]%10;
-
}
-
}
-
}
-
//4.把result数组再次逆序并转成String
-
StringBuilder sb = new StringBuilder();
-
//是否找到大整数的最高有效位
-
boolean findFirst = false;
-
for (int i = result.length - 1; i >= 0; i--) {
-
if(!findFirst){
-
if(result[i] == 0){
-
continue;
-
}
-
findFirst = true;
-
}
-
sb.append(result[i]);
-
}
-
return sb.toString();
-
}
-
-
public static void main(String[] args) {
-
String x = "3338429042340042304302404";
-
String y = "12303231";
-
System.out.println(multiply(x, y));
-
}
————————————
下面,我们的推导会有一些烧脑,请大家坐稳扶好~~
大整数从高位到低位,被平分成了两部分。设整数1的高位部分是A,低位部分是B;整数2的高位部分是C,低位部分是D,那么有如下等式:
如果把大整数的长度抽象为n,那么:
因此,整数1与整数2 的乘积可以写成下面的形式:
如此一来,原本长度为n的大整数的1次乘积,被转化成了长度为n/2的大整数的4次乘积(AC,AD,BC,BD)。
什么是master定理呢?
master定理的英语名称是master theorem,它为许多由分治法得到的递推关系式提供了渐进时间复杂度分析。
设常数a >= 1,b > 1,如果一个算法的整体计算规模 T(n) = a T(n / b) + f(n),那么则有如下规律:
假设两个长度为n的大整数相乘,整体运算规模是T(n) 。
根据刚才得到的结论,两个大整数相乘被拆分成四个较小的乘积:
所以在第一次分治时,T(n)和T(n/2)有如下关系:
T(n) = 4T(n/2) + f(n)
其中f(n)是4个乘积结果相加的运算规模,f(n)的渐进时间复杂度很明显是O(n)。
把这个关系带入到master定理的公式 T(n) = a T(n / b) + f(n) 当中,
此时 a=4, b=2。
此时,把a和b的值,以及f(n)的时间复杂度带入到master定理的第一个规律,也就是下面的规律:
发现正好符合条件。
怎么符合呢?推导过程如下:
所以我们的平均时间复杂度是:
如何做调整呢?其实很简单,连小学生都会:
这样一来,原本的4次乘法和3次加法,转变成了3次乘法和6次加法。
这样一来,时间复杂度是多少呢?
假设两个长度为n的大整数相乘,整体运算规模是T(n) 。
刚才我们说过,两个大整数相乘可以被拆分成三个较小的乘积,
所以在第一次分治时,T(n)和T(n/2)有如下关系:
T(n) = 3T(n/2) + f(n)
其中f(n)是6次加法的运算规模,f(n)的渐进时间复杂度很明显是O(n)。
此时让我们回顾一下master定理:
设常数a >= 1,b > 1,如果一个算法的整体计算规模 T(n) = a T(n / b) + f(n),那么则有如下规律:
对于T(n) = 3T(n/2) + f(n)这个关系式来说, a=3, b=2。
把a和b的值,以及f(n)的时间复杂度带入到master定理的第一个规律,也就是下面的规律:
发现正好符合条件。
怎么符合条件呢?推导过程如下:
所以我们的平均时间复杂度是:
2 和 1.59 之间的差距看似不大,但是当整数长度非常大的时候,两种方法的性能将是天壤之别。
下面展示一下实现代码。我们的代码非常复杂,在这里只作为参考,最重要的还是解决问题的思路:
-
/**
-
* 大整数乘法
-
* @param bigNumberA 大整数A
-
* @param bigNumberB 大整数B
-
*/
-
public static String bigNumberMultiply(String bigNumberA, String bigNumberB) {
-
boolean isNegative = false;
-
if ((bigNumberA.startsWith("-") && bigNumberB.startsWith("-"))
-
|| (!bigNumberA.startsWith("-") && !bigNumberB.startsWith("-"))) {
-
// 两数同符号的情况
-
bigNumberA = bigNumberA.replaceAll("-", "");
-
bigNumberB = bigNumberB.replaceAll("-", "");
-
} else if ((bigNumberA.startsWith("-") && !bigNumberB.startsWith("-"))
-
|| (!bigNumberA.startsWith("-") && bigNumberB.startsWith("-"))) {
-
// 两数不同符号的情况
-
bigNumberA = bigNumberA.replace("-", "");
-
bigNumberB = bigNumberB.replace("-", "");
-
isNegative = true;
-
}
-
// 如果两数长度之和小于10,直接相乘返回
-
if (bigNumberA.length() + bigNumberB.length() < 10) {
-
// 计算乘积
-
int tmp = (Integer.parseInt(bigNumberA) * Integer.parseInt(bigNumberB));
-
if (tmp == 0) {
-
return "0";
-
}
-
String value = String.valueOf(tmp);
-
if(isNegative){
-
value = "-" + value;
-
}
-
return value;
-
}
-
// 公式 AC * 10^n+((A-B)(D-C)+AC+BD) * 10^(n/2)+BD当中的a,b,c,d
-
String a, b, c, d;
-
if (bigNumberA.length() == 1) {
-
a = "0";
-
b = bigNumberA;
-
} else {
-
if (bigNumberA.length() % 2 != 0) {
-
bigNumberA = "0" + bigNumberA;
-
}
-
a = bigNumberA.substring(0, bigNumberA.length() / 2);
-
b = bigNumberA.substring(bigNumberA.length() / 2);
-
}
-
if (bigNumberB.length() == 1) {
-
c = "0";
-
d = bigNumberB;
-
} else {
-
if (bigNumberB.length() % 2 != 0) {
-
bigNumberB = "0" + bigNumberB;
-
}
-
c = bigNumberB.substring(0, bigNumberB.length() / 2);
-
d = bigNumberB.substring(bigNumberB.length() / 2);
-
}
-
// 按最大位数取值,以确定补零数目
-
int n = bigNumberA.length() >= bigNumberB.length() ? bigNumberA.length() : bigNumberB.length();
-
-
//t1,t2为中间运算结果,t3为乘法运算完毕的结果
-
String t1, t2, t3;
-
String ac = bigNumberMultiply(a, c);
-
String bd = bigNumberMultiply(b, d);
-
-
//t1=(A-B)(D-C)
-
t1 = bigNumberMultiply(bigNumberSubtract(a, b), bigNumberSubtract(d, c));
-
//t2=(A-B)(D-C)+AC+BD
-
t2 = bigNumberSum(bigNumberSum(t1, ac), bd);
-
//t3= AC * 10^n+((A-B)(D-C)+AC+BD) * 10^(n/2)+BD
-
t3 = bigNumberSum(bigNumberSum(Power10(ac, n), Power10(t2, n/2)), bd).replaceAll("^0+", "");
-
if (t3 == "")
-
return "0";
-
if(isNegative){
-
return "-" + t3;
-
}
-
return t3;
-
}
-
-
-
-
/**
-
* 大整数加法
-
* @param bigNumberA 大整数A
-
* @param bigNumberB 大整数B
-
*/
-
public static String bigNumberSum(String bigNumberA, String bigNumberB) {
-
-
if (bigNumberA.startsWith("-") && !bigNumberB.startsWith("-")) {
-
return bigNumberSubtract(bigNumberB, bigNumberA.replaceAll("^-", ""));
-
} else if (!bigNumberA.startsWith("-") && bigNumberB.startsWith("-")) {
-
return bigNumberSubtract(bigNumberA, bigNumberB.replaceAll("^-", ""));
-
} else if (bigNumberA.startsWith("-") && bigNumberB.startsWith("-")) {
-
return "-" + bigNumberSum(bigNumberA.replaceAll("^-", ""), bigNumberB.replaceAll("^-", ""));
-
}
-
-
//1.把两个大整数用数组逆序存储,数组长度等于较大整数位数+1
-
int maxLength = bigNumberA.length() > bigNumberB.length() ? bigNumberA.length() : bigNumberB.length();
-
int[] arrayA = new int[maxLength+1];
-
for(int i=0; i< bigNumberA.length(); i++){
-
arrayA[i] = bigNumberA.charAt(bigNumberA.length()-1-i) - '0';
-
}
-
int[] arrayB = new int[maxLength+1];
-
for(int i=0; i< bigNumberB.length(); i++){
-
arrayB[i] = bigNumberB.charAt(bigNumberB.length()-1-i) - '0';
-
}
-
//2.构建result数组,数组长度等于较大整数位数+1
-
int[] result = new int[maxLength+1];
-
//3.遍历数组,按位相加
-
for(int i=0; i<result.length; i++){
-
int temp = result[i];
-
temp += arrayA[i];
-
temp += arrayB[i];
-
//判断是否进位
-
if(temp >= 10){
-
temp -= 10;
-
result[i+1] = 1;
-
}
-
result[i] = temp;
-
}
-
//4.把result数组再次逆序并转成String
-
StringBuilder sb = new StringBuilder();
-
//是否找到大整数的最高有效位
-
boolean findFirst = false;
-
for (int i = result.length - 1; i >= 0; i--) {
-
if(!findFirst){
-
if(result[i] == 0){
-
continue;
-
}
-
findFirst = true;
-
}
-
sb.append(result[i]);
-
}
-
return sb.toString();
-
}
-
-
-
/**
-
* 大整数减法
-
* @param bigNumberA 大整数A
-
* @param bigNumberB 大整数B
-
*/
-
public static String bigNumberSubtract(String bigNumberA, String bigNumberB) {
-
int compareResult = compare(bigNumberA, bigNumberB);
-
if (compareResult == 0) {
-
return "0";
-
}
-
boolean isNegative = false;
-
if (compareResult == -1) {
-
String tmp = bigNumberB;
-
bigNumberB = bigNumberA;
-
bigNumberA = tmp;
-
isNegative = true;
-
}
-
//1.把两个大整数用数组逆序存储,数组长度等于较大整数位数+1
-
int maxLength = bigNumberA.length() > bigNumberB.length() ? bigNumberA.length() : bigNumberB.length();
-
int[] arrayA = new int[maxLength+1];
-
for(int i=0; i< bigNumberA.length(); i++){
-
arrayA[i] = bigNumberA.charAt(bigNumberA.length()-1-i) - '0';
-
}
-
int[] arrayB = new int[maxLength+1];
-
for(int i=0; i< bigNumberB.length(); i++){
-
arrayB[i] = bigNumberB.charAt(bigNumberB.length()-1-i) - '0';
-
}
-
//2.构建result数组,数组长度等于较大整数位数+1
-
int[] result = new int[maxLength+1];
-
//3.遍历数组,按位相加
-
for(int i=0; i<result.length; i++){
-
int temp = result[i];
-
temp += arrayA[i];
-
temp -= arrayB[i];
-
//判断是否进位
-
if(temp < 0){
-
temp += 10;
-
result[i+1] = -1;
-
}
-
result[i] = temp;
-
}
-
//4.把result数组再次逆序并转成String
-
StringBuilder sb = new StringBuilder();
-
//是否找到大整数的最高有效位
-
boolean findFirst = false;
-
for (int i = result.length - 1; i >= 0; i--) {
-
if(!findFirst){
-
if(result[i] == 0){
-
continue;
-
}
-
findFirst = true;
-
}
-
sb.append(result[i]);
-
}
-
String value = sb.toString();
-
if (isNegative) {
-
value = "-" + value;
-
}
-
return value;
-
}
-
-
-
// 比较大小
-
private static int compare(String x, String y) {
-
if (x.length() > y.length()) {
-
return 1;
-
} else if (x.length() < y.length()) {
-
return -1;
-
} else {
-
for (int i = 0; i < x.length(); i++) {
-
if (x.charAt(i) > y.charAt(i)) {
-
return 1;
-
} else if (x.charAt(i) < y.charAt(i)) {
-
return -1;
-
}
-
}
-
return 0;
-
}
-
}
-
-
-
// 扩大10的n次方倍
-
public static String Power10(String num, int n) {
-
for (int i = 0; i < n; i++) {
-
num += "0";
-
}
-
return num;
-
}
-
-
-
public static void main(String[] args) {
-
String x = "1513143";
-
String y = "9345963";
-
System.out.println(bigNumberMultiply(x, y));
-
}
需要注意的是,这段实现代码只适用于两个大整数长度相等的情况。如果想求解长度不等的整数相乘,只需要对代码做微小的改动,有兴趣的小伙伴没有试一试。
几点补充:
1. 文章最后的代码,经由网上技术博客的代码改动而来,仅做参考。
2. 关于快速傅里叶变换,有兴趣深入研究的小伙伴们可以参考《算法导论》第30章的内容。