对于a的n次幂求解这个问题,不少人看到后都觉得没有什么内容吧!我第一次想到这个问题也觉得没有什么内容,但是后来仔细想想,里面还真是有学问哦!
想想看如果我们求 a8 ,有以下两种方法:
1)a8 = a * a * a * a * a * a * a * a 需要计算 7次乘法
2)a 8 = (a * a) * A * A (其中A = a * a) 需要计算3次乘法
对于这么简单的一个算法计算步骤差别的差别是很大的
算法的思想:
一般的对于 a (2x + b) = a2x * a b,所以就有
1)b = 0时:a 2x + b = (ax)2;
2)b = 1时:a 2x + b = (ax)2 * a;
对于 an ,先把 n的二进制表示写出,那么有an = a (n1 n2 n3 n4 ..)= …
那么我们从左到右就可以如下表(n = 13的时候 1101):
n的二进制位 | 1 | 1 | 0 | 1 |
累乘 | a | a2 * a = a3 | (a3)2 = a6 | (a6)2 * a = a13 |
实现思路:
1)先将指数转换成二进制,用栈实现;
2)根据指数是1还是0进行相乘;
3)考虑到乘数太大,我们写一个大数相乘的算法。
大数相乘算法思想:
1)先把乘数列出来,第二行起每次右移一位,以12*34=408为例
(1,3) (1,4)
(2,3) (2,4)
2)将( )内的数两乘
(1,3=3) (1,4=4)
(2,3=6) (2,4=8)
3)相加,注意进位
(3) (4)
(6) (8)
-------------------------
3 10 8
-------------------------
4 0 8
大数相乘实现思路:
1)将大数作为字符串输入
2)将字符串反向存入一个int 型数组中,即:输入为“12345”,存成数组为a[0]=1,a[1]=2,a[2]=3...
3)将两个大数按整型数组(a[],b[])存好之后,按照手动计算的顺序进行计算
3.1)首先用a[0]与b[0...N-1]相乘,结果对应存入c[0...N-1]中
3.2)用a[1]与b[0...N-1]相乘,结果对应加到c[1...N-1]中(注意此处计算结果要与上一步的结果累加)
3.3)循环所有的数字得到一个结果数组c[2*N]
4)将结果数组进行分析得到结果,分析方法是将每个c[]中元素化为一位数字
import java.util.Stack;
public class Test {
public String power(int x, int n){
String basic = String.valueOf(x);
Stack<Integer> s = conversion(n, 2);
String result = "1";
while (!s.empty()) {
int i = s.pop();
switch (i) {
case 0:
result = bigMulti(result, result);
break;
case 1:
result = bigMulti(bigMulti(result, result), basic);
break;
}
}
return result;
}
private Stack<Integer> conversion(int x, int d){
// according to the formula: N = (N div d) * d + N mod d
Stack<Integer> s = new Stack<Integer>();
while (x != 0) {
s.push(x % d);
x = x / d;
}
return s;
}
private String bigMulti(String left, String right) {
int[] lefts = changeToArray(left);
int[] rights = changeToArray(right);
int tempLength = lefts.length + rights.length - 1;
int[] temp = new int[tempLength];
// 对应思路3
for (int i = 0; i < lefts.length; i++) {
for (int j = 0; j < rights.length; j++) {
temp[i + j] += lefts[i] * rights[j];
}
}
// 如果有大于10的,进位
for (int i = tempLength - 1; i >= 0; i--) {
if (temp[i] >= 10 && (i - 1) >= 0) {
temp[i - 1] += temp[i] / 10;
temp[i] = temp[i] % 10;
}
}
// 结果拼接成string
StringBuffer result = new StringBuffer();
for (int i = 0; i < tempLength; i++) {
result.append(temp[i]);
}
return result.toString();
}
private int[] changeToArray(String numStr){
int length=numStr.length();
int[] intNum=new int[length];
for(int i = 0;i< length; i++)
intNum[i]=Integer.parseInt(String.valueOf((numStr.charAt(i))));
return intNum;
}
public static void main(String[] args) {
long start = System.currentTimeMillis();
Test t = new Test();
String result = t.power(2, 10000);
long end = System.currentTimeMillis();
System.out.println("result is:" + result);
System.out.println("use time:" + (end - start));
}
}
【补充】Java中的BigInteger
-
在 Java 7 里面,就是用二重循环直接乘的。源代码:[BigInteger - Java7] (见1165行)
-
在 Java 8 里面,根据两个因数的大小,有三种乘法。源代码:[BigInteger - Java8] (见1464行):
- 当两个因数均小于
时,用二重循环直接相乘,复杂度为O(
),n为因数位数(下同);
- 否则,当两个因数均小于
时,采用 Karatsuba algorithm,其复杂度为O(
)≈O(
);
- 否则,采用 Toom-Cook multiplication,其复杂度为O(
)≈O(
)
- 当两个因数均小于
参考: