a的n次方的快速算法及大数相乘

对于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

1. 在 Java 7 里面，就是用二重循环直接乘的。源代码：[BigInteger - Java7] （见1165行）

2. 在 Java 8 里面，根据两个因数的大小，有三种乘法。源代码：[BigInteger - Java8] （见1464行）：

   • 当两个因数均小于 时，用二重循环直接相乘，复杂度为O()，n为因数位数（下同）；
   • 否则，当两个因数均小于时，采用 Karatsuba algorithm，其复杂度为O()≈O()；
   • 否则，采用 Toom-Cook multiplication，其复杂度为O()≈O()

参考：

【算法】大数乘法问题及其高效算法