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

对于a的n次幂求解这个问题，不少人看到后都觉得没有什么内容吧！我第一次想到这个问题也觉得没有什么内容，但是后来仔细想想，里面还真是有学问哦！

想想看如果我们求 a⁸ ，有以下两种方法：

1）a⁸  = a * a * a * a * a * a * a * a 需要计算 7次乘法

2）a ⁸  = (a * a) * A * A  (其中A = a * a) 需要计算3次乘法

对于这么简单的一个算法计算步骤差别的差别是很大的

 

 

算法的思想：

一般的对于 a ^{(2x + b)}  = a^2x * a ^b，所以就有

1）b = 0时：a ^{2x + b} = (a^x)²；

2）b = 1时：a ^{2x + b} = (a^x)² * a;

对于 aⁿ ，先把 n的二进制表示写出，那么有aⁿ  = 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[]中元素化为一位数字

 

 

[java]  view plain copy print ?

 

1. 1. import java.util.Stack;  
   2.   
   3. public class Test {  
   4.       
   5.     public String power(int x, int n){  
   6.         String basic = String.valueOf(x);  
   7.         Stack<Integer> s = conversion(n, 2);  
   8.   
   9.         String result = "1";  
   10.         while (!s.empty()) {  
   11.             int i = s.pop();  
   12.             switch (i) {  
   13.             case 0:  
   14.                 result = bigMulti(result, result);  
   15.                 break;  
   16.             case 1:  
   17.                 result = bigMulti(bigMulti(result, result), basic);  
   18.                 break;  
   19.             }  
   20.         }  
   21.         return result;  
   22.     }  
   23.       
   24.     private Stack<Integer> conversion(int x, int d){  
   25.         // according to the formula: N = (N div d) * d + N mod d  
   26.         Stack<Integer> s = new Stack<Integer>();  
   27.         while (x != 0) {  
   28.             s.push(x % d);  
   29.             x = x / d;  
   30.         }  
   31.         return s;  
   32.     }  
   33.   
   34.     private String bigMulti(String left, String right) {  
   35.         int[] lefts = changeToArray(left);  
   36.         int[] rights = changeToArray(right);  
   37.         int tempLength = lefts.length + rights.length - 1;  
   38.         int[] temp = new int[tempLength];  
   39.   
   40.         // 对应思路3  
   41.         for (int i = 0; i < lefts.length; i++) {  
   42.             for (int j = 0; j < rights.length; j++) {  
   43.                 temp[i + j] += lefts[i] * rights[j];  
   44.             }  
   45.         }  
   46.   
   47.         // 如果有大于10的，进位  
   48.         for (int i = tempLength - 1; i >= 0; i--) {  
   49.             if (temp[i] >= 10 && (i - 1) >= 0) {  
   50.                 temp[i - 1] += temp[i] / 10;  
   51.                 temp[i] = temp[i] % 10;  
   52.             }  
   53.         }  
   54.   
   55.         // 结果拼接成string  
   56.         StringBuffer result = new StringBuffer();  
   57.         for (int i = 0; i < tempLength; i++) {  
   58.             result.append(temp[i]);  
   59.         }  
   60.         return result.toString();  
   61.   
   62.     }  
   63.       
   64.      private int[] changeToArray(String numStr){     
   65.          int length=numStr.length();  
   66.          int[] intNum=new int[length];  
   67.          for(int i = 0;i< length; i++)     
   68.              intNum[i]=Integer.parseInt(String.valueOf((numStr.charAt(i))));     
   69.          return intNum;     
   70.      }  
   71.       
   72.     public static void main(String[] args) {  
   73.         long start = System.currentTimeMillis();  
   74.         Test t = new Test();  
   75.         String result = t.power(2, 10000);  
   76.         long end = System.currentTimeMillis();  
   77.         System.out.println("result is:" + result);  
   78.         System.out.println("use time:" + (end - start));  
   79.     }  
   80. }  

转载于:https://www.cnblogs.com/xuweili/articles/3387210.html