Pow(x, n) 递归,非递归

实现 pow(x, n) ，即计算 x 的 n 次幂函数。
示例1: 输入: 2.00000, 10 输出: 1024.00000
示例2: 输入: 2.10000, 3 输出: 9.26100
输入: 2.00000, -2 输出: 0.25000 解释: 2^(-2) = 1/(2 ^(2))= 1/4 = 0.25
说明: 1: -100.0 < x < 100.0 2: n 是 32 位有符号整数，其数值范围是 [−2^(31), 2 ^ (31) − 1]

方法一 暴力

 public static double myPow(double x, long n) {
        long N = n;          // x:2, n:-2       x = 1/2 = 0.2 N = -N = -(n) = -(-n) = n
        double res = 1;
        if(N < 0){
            x = 1/x;
            N = -N;   //
        }
        for(int i = 0; i < N; i++) {
            res = res * x;
		}
        return res;
    }

复杂度分析: 时间复杂度：O(n)O(n). 我们需要将 x 连乘 n 次。空间复杂度：O(1)O(1). 我们只需要一个变量来保存最终 x 的连乘结果。

方法二 递归

 public static double myPow(double x, long n) {
        long N = n;          // x:2, n:-2       x = 1/2 = 0.2 N = -N = -(n) = -(-n) = n
        double res = 1;
        if(N < 0){
            x = 1/x;
            N = -N;   //
        }
        return fastPow(x,N);

    }

    public static double fastPow(double x, long n) {
        if(n == 0) return 1;
        double half = fastPow(x, n >> 1);
        boolean odd = (n & 1) == 1;
        half *= half;
        if (odd) return half * x;
        return half;
    }

// 等同于下面
 public static double fastPow(double x, long n) {
        if (n == 0) {
            return 1.0;
        }
        double half = fastPow(x, n / 2);
        if (n % 2 == 0) {
            return half * half;
        } else {
            return half * half * x;
        }
    }

方法二 非递归

推理过程:

 public static double myPow(double x, long n) {
        long N = n;          // x:2, n:-2       x = 1/2 = 0.2 N = -N = -(n) = -(-n) = n
        double res = 1;
        if(N < 0){
            x = 1/x;
            N = -N;   //
        }
        return fastPow(x,N);
    }

   /*
    任何数与1进行按位与 都可以取出他原来的最后一个二进制位值
      10101
    *&00001
    --------
          1

          0b10101 >> 1   // 0b10101右移一位那么最后一位1消失,前面用符号位补平,正数符号位为0
          0b01010
           &00001
    --------------
                0  >> 1 ==> 0b00101
                             &00001
                          ----------
                                   1   >> 1 ==> 0b0010
                                                &00001
                                               -------
                                                     0 >> 1 ==> 0b0001
                                                                 &0001
                                                                 ------
                                                                 0b0001 >> 1 ==> 0b0000

    * */

    public static double fastPow(double x, long n) {
       double res = 1;
       while (n > 0) {
           if ((n & 1) == 1) {
               // 如果最后一个二进制位为1,就累乘x起来,如果最后一个二进制位为0,因为任何数的0次方都是1,所以什么都不做
               res *= x;
           }
           System.out.println(n & 1); // 将所有二进制位打印出来; 如果n为21那么打印结果为 0101因为是从最右端开始打的10的每一个二进制位 那么反过来写 10 = (1010)二进制位
          x *= x;// 例如:3 * 3 = 3^(2)   ⇒  3^(2) * 3^ (2) = 3 ^(4) ,每次的结果都是前一次累积的结果
          // 舍弃掉最后一个二进制位
           n = n >> 1;  // 例如: 10的二进制1010 右移一位二进制位为101变为5 ... 直至变为0,退出循环 
       }
       return res;
    }

时间复杂度为O(logN),空间复杂度为O(1)