1、直接循环求（超时）

 1 double myPow(double x, int n) {
 2         if(n==0||x==1)
 3         return 1;
 4         double temp=x;
 5         if(n<0){
 6             x=1/x;
 7             temp=x;
 8             n*=-1;
 9         }
10         while(--n>0)
11         x*=temp;
12         return x;
13     }

2、递归处理（4ms,34%;5.9MB,54%）

时间复杂度O（log n）:递归层数

空间复杂度O（log n）:递归层数

 1 class Solution {
 2 public:
 3     double myPow(double x, int n) {
 4         if(x==1||n==0)
 5         return 1;
 6         return n>0? recurPow(x,n):1.0/recurPow(x,n);
 7     }
 8     double recurPow(double x,int n){
 9         if(n==0)
10         return 1.0;
11         //直接定位到n最小的时候，y代表的是过去的数据
12         double y=recurPow(x,n/2);
13         //这个是通过判断现在数据的n的奇偶，从而用过去的数据得到现在的数据
14         //例如现在的n是1，y也是1，通过y*y*x可得现在的数据，即由x^0->x^1
15         //例如现在的n是2，y是x，通过y*y可得现在的数据，即由x^1->x^2
16         return n%2==0? y*y:y*y*x;
17     }
18 };

3、利用二进制规律求解(0ms,100%;5.6MB,100%)

时间复杂度：O（log n）:即while()的执行次数

空间复杂度：O（1）

 1 class Solution {
 2 public:
 3     double myPow(double x, int n) {
 4         //这里用long是因为当n取-2^31时，-n反转即得到了2^31
 5         //但int的表示范围是-2^31~2^31-1,所以上面的反转会溢出
 6         long N=n;
 7         if(x==1||n==0)
 8         return 1;
 9         return N>0? binaryPow(x,N):1.0/binaryPow(x,-N);
10     }
11     //x^n刚好等于x^(n的二进制的1对应的十进制)的总和
12     //如x^10等于x^(2^3+2^1)等于(x^8*x^2),其中3和1分别对应10的二进制中的1
13     double binaryPow(double x,long n){
14         //sum保存目标值，num保存x^(n的二进制的1对应的十进制)
15         double sum=1;
16         double num=x;
17         while(n!=0){
18             if(n%2==1){
19                 sum*=num;
20             }
21             num*=num;
22             n/=2;
23         }
24         return sum;
25     }
26 };