leetcode 精选top面试题

50. Pow(x, n)

实现 pow(x, n) ，即计算 x 的 n 次幂函数。

示例 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] 。

思路一：二分法 + 递归 （分治思想）

如果n是偶数：myPow(x, n) = myPow(x, n/2) * myPow(x, n/2)；

如果n 是奇数，还需要多乘一个x: myPow(x, n) = myPow(x, n/2) * myPow(x, n/2) * x；

如果n 是偶数，需要转换成求 1/x的-n次幂， 即求 myPow(1/x, -1 n);

递归的边界是n == 0, 返回0， 任何数的0次幂都是1。

另外一些特殊值x == 0, x == 1, n == 1， 这些值的结果都是可以预知的。

class Solution {

    public double myPow(double x, int n) {
        // 二分法 + 递归(分治思想)
        if(x == 0 || x == 1 || n == 1){ // 0 的任何次方都等于 0,1 的任何次方都等于 1
            return x;
        }
        if(n == 0){
            return 1;
        }
        if(n < 0){  // 如果指数为负数，转换成正数
            return myPow(1/x, -1 n);    // 当n刚好是Integer.MIN_VALUE时，乘以一个-1会溢出
        }
        double sqrt = myPow(x, n/2);
        if((n&1) == 0){
            return sqrt * sqrt;
        }else{
            return sqrt * sqrt * x;
        }
    }
}

但是当n为负数且刚好是Integer.MIN_VALUE时，乘以一个-1会溢出， 所以必须借助一个中间函数，把指数类型变成long类型，改变后的编码如下：

class Solution {

    public double quickMulti(double x, long n){
        if(n == 0){         // 递归结束的边界
            return 1;
        }
        double sqrt = quickMulti(x, n/2);
        if((n&1) == 0){
            return sqrt * sqrt;
        }else{
            return sqrt * sqrt * x; // 奇数要多乘一个x
        }
    }

    public double myPow(double x, int n) {
        // 二分法 + 递归(分治思想)
        if(x == 0 || x == 1 || n == 1){ // 0 的任何次方都等于 0,1 的任何次方都等于 1
            return x;
        }
        return n < 0 ? quickMulti(1/x, -1 * (long)n) : quickMulti(x, n);
    }
}

leetcode 执行用时：1 ms, 在所有 Java 提交中击败了97.96%的用户，内存消耗：37.7 MB, 在所有 Java 提交中击败了30.68%的用户

复杂度分析：

时间复杂度: O(logn)。因为采用的是二分法，所以时间复杂度为O(logn)。

空间复杂度：O(logn)。空间复杂度取决于递归深度，而递归深度刚好是logn, 所以空间复杂度为O(logn)。

思路二：迭代法

思路参考：https://leetcode-cn.com/problems/powx-n/solution/powx-n-by-leetcode-solution/

 每个二进制数位都有一个权值，权值如下图所示，最终结果就等于所有二进制位为1的权值之积, 例如上述 x^77次方对应的二进制 (1001101) 和每个二进制位的权值如下和每个二进制位的权值如下

最终结果就是所有二进制位为1的权值之积：x^1 * x^4 * x^8 * x^64 = x^77

而且我们不必预先把每一个二进制位的权值计算出来，我们可以一边计算结果，一边计算权值

class Solution {

    public double myPow(double x, int n) {
        // 迭代算法，利用二进制位
        if(x == 0){ // 0 的任何次方都等于 0,1 的任何次方都等于 1
            return x;
        }

        long power = n;    // 为了保证-n不溢出，先转换成long类型
        if(n < 0){         // 如果n小于0， 求1/x的-n次方
            power *= -1;
            x = 1 / x;
        }
        double weight = x;  // 权值初值为x, 即二进制位第1位的权值为x^1
        double res = 1;
        while(power != 0){
            // 如果当前二进制位为1， 让结果乘上这个二进制位上的权值, 
            // 该位权值在上一轮迭代中已经计算出来了
            if((power & 1) == 1){   
                res *= weight;
            }
            weight *= weight;   // 计算下一个二进制位的权值
            power /= 2;
        }
        return res;
    }
}

leetcode 执行用时：1 ms, 在所有 Java 提交中击败了97.96%的用户, 内存消耗：36.5 MB, 在所有 Java 提交中击败了69.88%的用户， 空间效率确实是提升了一些。

复杂度分析：

时间复杂度：O(logn)。利用的二进制位的思想，所以迭代次数是二进制位的长度，所以时间复杂度为O(logn)。

空间复杂度: O(1)。没有借助递归，其他变量都是常量的空间，所以空间复杂度为O(1)。