剑指 Offer 16. 数值的整数次方

一、题目 

题目链接：力扣

实现 pow(x, n) ，即计算 x 的 n 次幂函数（即，x^n）。不得使用库函数，同时不需要考虑大数问题。

示例 1：

输入：x = 2.00000, n = 10
输出：1024.00000

示例 2：

输入：x = 2.10000, n = 3
输出：9.26100

示例 3：

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

提示：

-100.0 < x < 100.0
-2^31 <= n <= 2^31 - 1
-10^4 <= x^n <= 10^4

---

二、题解

1、思路

一个方法（快速幂），两种理解方式（二分法角度、二进制角度），两种实现方式（递归、迭代）。

🚚 快速幂（二分法角度）

「快速幂算法」的本质是分治算法。举个例子，如果我们要计算 x^64，我们可以按照：

的顺序，从 x 开始，每次直接把上一次的结果进行平方，计算 6 次就可以得到 x^64 的值，而不需要对 x 乘 63 次 x。

再举一个例子，如果我们要计算 x^77，我们可以按照：

的顺序，在x^64的步骤中，我们直接把上一次的结果进行平方，而x^77的步骤中，我们把上一次的结果进行平方后，还要额外乘一个 x。但如果我们从右往左看，分治的思想就十分明显了：

递归思路：

迭代思路：

由于每次递归都会使得指数减少一半，因此递归的层数为 O(logn)，算法可以在很快的时间内得到结果。

🚚 快速幂（二进制角度）

根据以上推导，可把计算 x^n 转化为解决以下问题：

即通过取n对应二进制的右侧第一位，计算上方两个公式后，右移一位，再次通过右侧第一位计算上面两个公式的，不断循环累乘。

🚚 两种方法的统一

第二条怎么理解？对于，不考虑bi，x^（2^0）→ x^（2^1），x^（2^1）→ x^（2^2），都是经过平方，n&1也就是判断奇偶，也就是说二进制和二分两种理解方式实质是相同的。都是：

🚚 但有一点需要格外注意：

​

注意提示中的n取值范围，当n为-2^31的时候，代码中会将n转化为-n，那么int最大是2^31-1，导致溢出，因此需要使用long long类型。 

注：long、int占4个字节，long long站8个字节（64位）。

🚚 第二次看的时候出错：

// 这样n还是会转化为-n之后，再赋值给N的，仍然存在溢出的风险

long long N;

N = -n;

2、代码实现

🚚 快速幂（二分法角度） + 递归 

从后往前

class Solution {
public:
    double myPow(double x, int n) {
        if(n == 0)return 1;// N等于0直接返回1

        // 这里一定要将n变换成long long类型，否则会溢出，上面解释
        long long N = n;
        // 除了n=0，再分为大于0、小于0两种情况分别求解
        return n>0 ? quick_multi(x, N) : 1.0/quick_multi(x, -N);
    }

private:
    // 快速乘求x^n
    // 通过上面的调用，此处的n一定为正值
    double quick_multi(double x, int n)
    {
        if(n == 0)return 1;// 递归截止条件
        double ans = quick_multi(x, n/2);
        return n%2 == 0 ? ans*ans : ans*ans*x;// 对奇偶分治
    }   
};

第二次的写法： 

class Solution {
public:
    double myPow(double x, int n) {
        long long N = n;
        
        // N分三种情况
        if(N == 0)return 1;
        else if(N > 0) 
        {
            // N又分为奇偶两种情况
            return N%2==0 ? myPow(x*x, N/2) : x*myPow(x*x, N/2);
        }
        else
        {
            N = -N;
            return N%2 ==0 ? 1/myPow(x*x, N/2) : 1/(x*myPow(x*x, N/2));// 1/后面这个是整体，一定要加括号
        }
    }
};

🚚 快速幂（二分法角度） + 迭代 

从后往前

class Solution {
public:
    double myPow(double x, int n) {
        if(n == 0)return 1;
        
        long long N = n;
        if(N < 0)
        {
            x = 1.0 / x;
            N = -N;
        }

        double res = 1;
        while(N > 0)
        {
            // 如果N是奇数
            if(N%2 == 1)
            {
                res *= x;
                x *= x;
                N /= 2;
            }
            else// 如果N是偶数
            {
                x *= x;
                N /= 2;
            }
        }
        return res;
    }
};

第二次写法：

class Solution {
public:
    double myPow(double x, int n) {
        double res = 1;// 一定要是double，不能是int
        long long N = n;
        N = abs(N);
        while(N != 0)
        {
            if(N % 2 == 0)
            {
                x = x*x;
                N = N/2;
            }
            else
            {
                res *= x;
                x = x*x;
                N = N/2;
            }
        }
        // 这里一定要判断n的值，因为N现在一定为0
        return n > 0 ? res : 1/res;
    }
};

3、复杂度分析

🚚 快速幂（二分法角度） + 递归

时间复杂度：O(n)；

空间复杂度：O(n)。

🚚 快速幂（二分法角度） + 迭代 

时间复杂度：O(n)；

空间复杂度：O(1)。

4、运行结果

🚚 快速幂 + 递归 

🚚 快速幂（二分法角度） + 迭代