STL源码分析之power算法

关于算法power

一般我们遇到要实现power算法，最直接就是如下实现：

[cpp] view plain copy print ?

1. Int power(int x, unsigned int n)  
2. {  
3.     Int result = 1;  
4.         While(n--)  
5.         result *= x;  
6.         return result;  
7. }  

然而，这样计算的复杂度为O(n)

 

想要改进，因为 x^n = x^(n/2) * x^(n/2)，所以我们想，只要计算出了x^(n/2)那么x^n也就直接得出了，于是改为如下实现：

[cpp] view plain copy print ?

1. Int power(int x, unsigned int n)  
2. {  
3.     if(n == 0)  
4.         Return 1;  
5.         else if(n==1)  
6.                 return x;  
7.         else  
8.         {  
9.           Int r = power(x, n/2);  
10.           If(n % 2 == 0)  
11.            Return r*r  
12.           Else    
13.             Return r*r*x;  
14.          }  
15. }  

 

既然走到了这里，且我们看到了递归，那继续优化的方法就是不使用递归，因为递归不仅可能导致内存栈溢出，还会产生很多不必要的计算。

这里，我们可能会想到斐波那契数列，教科书中讲解递归总是拿这个例子，但我们知道递归并非最优。于是我们按照将斐波那契数列递归形式改为循环形式的思路，将我们当前的power函数修改为循环：

         比如我们要求x^19 ，这里我们不再是采用 x^9* x^10，而是使用 x^16 * x^2 * x^1，根据19的二进制数进行计算，19的二进制为10011.

[cpp] view plain copy print ?

1. Int power(int x, unsigned int n)  
2. {  
3.         If(n == 0)  
4.             Return 1;  
5.     Int result = 1;  
6.     While(n)  
7.     {  
8.                If(n & 1)                    //当该位为1，则乘到结果去  
9.                 Result *= x;            //最后 result = x * x^2 * x^16  
10.                n >>= 1;  
11.                x  *= x;             //注意，这里是x*x所以是x^1, x^2, x^4, x^8,x^16  
12.                     //是成倍的上去的, x值是在不断变化的  
13.         }  
14. }  

于是我们理解stl中的power也就容易了:

//计算x^n

[cpp] view plain copy print ?

1. int power(int x, unsigned int n)  
2. {  
3.          if(n == 0)  
4.          {  
5.                    return1;  
6.          }  
7.          else  
8.          {  
9.                    while((n & 1) == 0)                     //去掉后几位的0  
10.                    {  
11.                             n>>= 1;  
12.                             x*= x;  
13.                    }  
14.          }  
15.          int result = x;  
16.          n>>= 1;  
17.          while(n != 0)                                         //大体一样  
18.          {         
19.                    x*= x;  
20.                    if((n & 1) != 0)  
21.                             result*= x;  
22.                    n>>= 1;  
23.          }  
24.          return result;  
25. }  

//这里我们比较一下，多了一个步骤，去掉了后几位的0，大概是能够增加效率的吧！