剑指Offer16 数值的整数次方

实现函数double Power(double base, int exponent)，求base的exponent次方。不得使用库函数，同时不需要考虑大数问题。

示例 1:

输入: 2.00000, 10
输出: 1024.00000
示例 2:

输入: 2.10000, 3
输出: 9.26100
示例 3:

输入: 2.00000, -2
输出: 0.25000
解释: 2-2 = 1/22 = 1/4 = 0.25

说明:

-100.0 < x < 100.0
n 是 32 位有符号整数，其数值范围是 [−231, 231 − 1] 。

题目不新鲜，但是要注意几个点：

1.注意溢出，这里书上没有考虑INT_MIN取反溢出的问题

2.尽量使用位运算，效率更高

3.使用幂计算，效率为O(logn)

 1 class Solution {
 2 public:
 3     double myPow(double x, int n) {
 4         if(!x )
 5             throw ("x equal to zero error");
 6         long long absn=n;
 7         if(n<0)
 8             absn=-absn;
 9         double result=power(x,absn);
10         if(n<0)
11             return 1.0/result;
12         return result;
13     }
14 
15     double power(double base, long long exponent)
16     {
17         if(!exponent)
18             return 1;
19         if(exponent==1)
20             return base;
21         double ret=power(base, exponent>>1);
22         ret*=ret;
23         if(exponent&1==1)
24             ret*=base;
25         return ret;
26     }
27 };

第二次做，一是没有想到递归的方法，然后处理INT_MIN转化成INT_MAX会溢出的问题，但是增加了错误处理。

 1 enum{Valid, InValid};
 2 int g_myPow=Valid;
 3 
 4 class Solution {
 5 public:
 6     double myPow(double x, int n) {
 7         if(x<-100.0 || x>100.0){
 8             g_myPow=InValid;
 9             return 0.0;
10         }
11         long long absn=abs(n);
12         double ret=recursive_pow(x,absn);
13         if(n<0)
14             return 1/ret;
15         return ret;
16     }
17 
18     double recursive_pow(double base, long long exp){
19         if(exp==0)
20             return 1;
21         if(exp==1)
22             return base;
23         double ret=recursive_pow(base,exp>>1);
24         ret*=ret;
25         if(exp&1==1)
26             ret*=base;
27         return ret;
28     }
29 };