050.Pow(x, n)

作者：沉默王二
发布时间：2024-09-29T18:00:46.901+0800

---

二哥瞎逼逼：人生总是起起伏伏，当你以为自己稳了的时候，冷不丁就会跌入谷底。所以当你取得一些成绩的时候，一定要有敬畏之心，不要张扬。时刻牢记自己就是一个普通人，这样你才会更加长久的生命力。LeetCode 有这么多题，你就是要不停的刷，才有希望举一反三。坚持吧，我们一起努力。

题意

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

难度

中等

示例

示例 1：

输入：x = 2.00000, n = 10

示例 2：

输入：x = 2.10000, n = 3

示例 3：

输入：x = 2.00000, n = -2

解释：2-2 = 1/22 = 1/4 = 0.25

分析 1

在 029.两数相除 中，我们利用了 快速加法 来实现 乘法 ，而Pow(x, n)作为 “乘法Plus版” ，能不能也利用 快速乘法 来实现呢？

当然是可以的！

我们先来考虑二进制拆分，例如7可以用二进制表示为111来表示，转化为十进制就是1 * 1 + 1 * 2 + 1 * 4，那么 就是 ，再例如10可以用二进制表示1010来表示，再转化为十进制就是0 * 1 + 1 * 2 + 0 * 4 + 1 * 8，那么 就可以变成 。

对十进制和二进制之间转化还没有概念的球友可以看看**B 站上这个视频 **，讲的很清晰：

截图来自B 站的三乐大掌柜

发现了没？

我们只需要计算n在二进制表示下，1的位上相应的x的幂即可，然后再将它们相乘即可。

可是这又引出了另外一个问题——总不能从1依次到n算出每个二进制位上对应的幂吧？

实际上并不用这么麻烦，既然用到二进制了，就要善于利用二进制的特性！！！

二进制下的每一位，其实对应着上一位的两倍。假如我们计算的是x的幂，其实计算的是上一位的 平方 。

当n为负数怎么处理呢？

实际上是从 变成了 的情况，所以还是只需要计算出 ，然后再用 1 除以结果即可。

来看题解方法：

class Solution {

    // 判断 n 的正负，如果 n > 0 则 f = 1，否则 f = -1        int f = n > 0 ? 1 : -1;
    // 使用 long 类型存储 n 的绝对值，避免 n 是 Integer.MIN_VALUE 时溢出        long up = n;        up = Math.abs(up);
    // 初始化结果为 1        double res = 1;
    // 快速幂：逐位处理 n 的二进制表示        while (up > 0) {            // 如果当前的二进制位为 1，那么将当前的 x 乘到结果中            if ((up & 1) == 1) { // 位与运算，检查二进制位的最低位是否为 1                res = res * x;            }
        // 每次将 x 平方（相当于 n 除以 2），从而将幂次的处理往下移一位            x = x * x;
        // 右移 up，相当于对 n 的二进制进行右移一位，处理下一位            up >>= 1;        }
    // 如果 n 是正数则直接返回结果，如果 n 是负数则返回 1.0 / res        return f == 1 ? res : 1.0 / res;    }}

来看一下题解效率，还不错，很高，直接击败了 100% 的 Java 提交：

分析 2

分析 1 中我们用了位运算，这对于有些初学算法的球友来说，可能并不是很友好，那有没有更简单一点的题解思路呢？

有，直接调用 Java 提供的 Math.pow 方法，直接返回结果即可，哈哈哈哈😄。

class Solution {

    return Math.pow(x, n);    }}

来看一下题解效率，仍然 beat 100%。说真的，Java 的强大之处就在于此，当别的语言需要实现很复杂的算法时，JDK 早为你提供了，直接调用就好了。

只不过该方法是一个 native 方法，不然可以看看它是怎么实现的。

分析 3

当然了，这道题的本质还是希望我们自己去实现一个 Pow 方法，最直接的暴力算法就是循环 n 次，然后累乘就好了：

public double pow(double x, int n) {

for (int i = 0; i < n; i++) {        res *= x;    }    return res;}

不过我们还需要考虑一些边界情况，比如 n 为负数的情况，这时候我们需要将 x 变为 1/x，然后再将 n 变为正数，这样就可以直接调用上面的方法了。

class Solution {

// 计算 x 的 n 次幂函数    public double myPow(double x, int n) {        // 如果 n 为 0，根据指数规则，任何数的 0 次幂都为 1        if (n == 0) {            return 1;        }
    // 如果 n 为负数，将 x 取倒数并将 n 转为正数        if (n < 0) {            x = 1 / x;  // 负指数转换为倒数            n = -n;     // 将 n 转为正数（此处可能会出现溢出风险）        }
    // 计算 x^n，调用辅助函数 pow        return pow(x, n);    }
// 辅助函数，计算 x 的 n 次幂    public double pow(double x, int n) {        double res = 1; // 初始化结果为 1（x^0 = 1）                // 循环 n 次，每次将 x 乘入结果 res 中，逐步累积 x 的 n 次幂        for (int i = 0; i < n; i++) {            res *= x;        }
    // 返回最终计算的结果        return res;    }}

可惜的是超出时间限制了。

for 循环的时间复杂度为 O(n)，我们可以使用快速幂算法来将时间复杂度优化为 O(log n)。

快速幂的核心思想是指数折半，我们可以将 拆分成更小的问题来解决。

• 如果 n 是偶数，可以利用公式：
• 如果 n 是奇数，则可以进一步分解为 。
• 对于 n 为负数的情况，可以转换为 。

来看完整的题解：

class Solution {

    // 处理 n 为负数的情况        long N = n; // 解决 -Integer.MAX_VALUE 溢出的情况。        if (N < 0) {            x = 1 / x;            N = -N;        }        return fastPow(x, N);    }
// 递归实现快速幂    private double fastPow(double x, long n) {        // 基本情况：当 n 为 0 时，x^0 = 1        if (n == 0) {            return 1.0;        }
    // 递归计算 x^(n/2)，将 n 除以 2 来缩小问题规模        double half = fastPow(x, n / 2);
    // 如果 n 是偶数，x^n = (x^(n/2)) * (x^(n/2)) = half * half        if (n % 2 == 0) {            return half * half;        }         // 如果 n 是奇数，x^n = x * (x^(n/2)) * (x^(n/2)) = half * half * x        else {            return half * half * x;        }    }
public static void main(String[] args) {        Solution solution = new Solution();        System.out.println(solution.myPow(2.0, 10));  // 输出: 1024.0        System.out.println(solution.myPow(2.1, 3));   // 输出: 9.261        System.out.println(solution.myPow(2.0, -2));  // 输出: 0.25    }}

这次题解效率就高多了。

总结

二进制不仅仅可以用来表示数据，还可以利用它来实现很多算法，提高效率。

这道题的本质是希望我们实现一个 Pow 方法，暴力算法的题解效率比较低，所以要用快速幂算法。

力扣链接：https://leetcode.cn/problems/powx-n/

一步一个脚印

不积跬步无以至千里，不积小流无以成江海。LeetCode - 100天从算法小白到卷王正式启动了，我们计划周一到周五至少每天更新一篇，周六周日更新一篇，目标 300 道 LeetCode 经典题。

PDF 版本目前只针对**二哥编程星球 的球友开放，如果你也想一起打卡学习算法的话，戳链接 **加入我们吧。

一个人可以走得很快，但一群人才能走得更远。二哥编程星球 （目前已有 6300 多名球友加入）里面的每个球友都非常的友善，除了鼓励你，还会给你提出合理的建议，一起冲！

• 语雀专栏地址+密码可通过星球置顶帖查看：https://t.zsxq.com/15rEo9Pdu
• 这道题可以说完全重写了，给出 3 道大家完全都能掌握的题解（主要是二进制和十进制的关系，以及快速幂算法）。
• 增加代码注释，这样大家更容易看懂并掌握题解；
• 增加参考资料，这样大家可以从零基础直接开刷，减轻新手刷题的阻力；
• 增加手绘图，这样大家更容易理解解题思路；
• 增加 ACM 输入输出，这样大家可以在 Intellij IDEA 中进行调试；
• 增加题解模拟，这样大家可以根据题解模拟整个题解过程，看完会有一种“哦哦”恍然大悟的感觉；
• 图片上传至 OSS 并配合 CDN，提升大家在技术派网站中的阅读体感。
• 另外，这一版本会作为 PDF 的终稿随后在星球进行发布。
• 技术派阅读地址：https://paicoding.com/column/7/50

二哥瞎逼逼：人生总是起起伏伏，当你以为自己稳了的时候，冷不丁就会跌入谷底。所以当你取得一些成绩的时候，一定要有敬畏之心，不要张扬。时刻牢记自己就是一个普通人，这样你才会更加长久的生命力。LeetCode 有这么多题，你就是要不停的刷，才有希望举一反三。坚持吧，我们一起努力。

题意

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

难度

中等

示例

示例 1：

输入：x = 2.00000, n = 10

示例 2：

输入：x = 2.10000, n = 3

示例 3：

输入：x = 2.00000, n = -2

解释：2-2 = 1/22 = 1/4 = 0.25

分析 1

在 029.两数相除 中，我们利用了 快速加法 来实现 乘法 ，而Pow(x, n)作为 “乘法Plus版” ，能不能也利用 快速乘法 来实现呢？

当然是可以的！

我们先来考虑二进制拆分，例如7可以用二进制表示为111来表示，转化为十进制就是1 * 1 + 1 * 2 + 1 * 4，那么 就是 ，再例如10可以用二进制表示1010来表示，再转化为十进制就是0 * 1 + 1 * 2 + 0 * 4 + 1 * 8，那么 就可以变成 。

对十进制和二进制之间转化还没有概念的球友可以看看**B 站上这个视频 **，讲的很清晰：

截图来自B 站的三乐大掌柜

发现了没？

我们只需要计算n在二进制表示下，1的位上相应的x的幂即可，然后再将它们相乘即可。

可是这又引出了另外一个问题——总不能从1依次到n算出每个二进制位上对应的幂吧？

实际上并不用这么麻烦，既然用到二进制了，就要善于利用二进制的特性！！！

二进制下的每一位，其实对应着上一位的两倍。假如我们计算的是x的幂，其实计算的是上一位的 平方 。

当n为负数怎么处理呢？

实际上是从 变成了 的情况，所以还是只需要计算出 ，然后再用 1 除以结果即可。

来看题解方法：

class Solution {

    // 判断 n 的正负，如果 n > 0 则 f = 1，否则 f = -1        int f = n > 0 ? 1 : -1;
    // 使用 long 类型存储 n 的绝对值，避免 n 是 Integer.MIN_VALUE 时溢出        long up = n;        up = Math.abs(up);
    // 初始化结果为 1        double res = 1;
    // 快速幂：逐位处理 n 的二进制表示        while (up > 0) {            // 如果当前的二进制位为 1，那么将当前的 x 乘到结果中            if ((up & 1) == 1) { // 位与运算，检查二进制位的最低位是否为 1                res = res * x;            }
        // 每次将 x 平方（相当于 n 除以 2），从而将幂次的处理往下移一位            x = x * x;
        // 右移 up，相当于对 n 的二进制进行右移一位，处理下一位            up >>= 1;        }
    // 如果 n 是正数则直接返回结果，如果 n 是负数则返回 1.0 / res        return f == 1 ? res : 1.0 / res;    }}

来看一下题解效率，还不错，很高，直接击败了 100% 的 Java 提交：

分析 2

分析 1 中我们用了位运算，这对于有些初学算法的球友来说，可能并不是很友好，那有没有更简单一点的题解思路呢？

有，直接调用 Java 提供的 Math.pow 方法，直接返回结果即可，哈哈哈哈😄。

class Solution {

    return Math.pow(x, n);    }}

来看一下题解效率，仍然 beat 100%。说真的，Java 的强大之处就在于此，当别的语言需要实现很复杂的算法时，JDK 早为你提供了，直接调用就好了。

只不过该方法是一个 native 方法，不然可以看看它是怎么实现的。

分析 3

当然了，这道题的本质还是希望我们自己去实现一个 Pow 方法，最直接的暴力算法就是循环 n 次，然后累乘就好了：

public double pow(double x, int n) {

for (int i = 0; i < n; i++) {        res *= x;    }    return res;}

不过我们还需要考虑一些边界情况，比如 n 为负数的情况，这时候我们需要将 x 变为 1/x，然后再将 n 变为正数，这样就可以直接调用上面的方法了。

class Solution {

// 计算 x 的 n 次幂函数    public double myPow(double x, int n) {        // 如果 n 为 0，根据指数规则，任何数的 0 次幂都为 1        if (n == 0) {            return 1;        }
    // 如果 n 为负数，将 x 取倒数并将 n 转为正数        if (n < 0) {            x = 1 / x;  // 负指数转换为倒数            n = -n;     // 将 n 转为正数（此处可能会出现溢出风险）        }
    // 计算 x^n，调用辅助函数 pow        return pow(x, n);    }
// 辅助函数，计算 x 的 n 次幂    public double pow(double x, int n) {        double res = 1; // 初始化结果为 1（x^0 = 1）                // 循环 n 次，每次将 x 乘入结果 res 中，逐步累积 x 的 n 次幂        for (int i = 0; i < n; i++) {            res *= x;        }
    // 返回最终计算的结果        return res;    }}

可惜的是超出时间限制了。

for 循环的时间复杂度为 O(n)，我们可以使用快速幂算法来将时间复杂度优化为 O(log n)。

快速幂的核心思想是指数折半，我们可以将 拆分成更小的问题来解决。

• 如果 n 是偶数，可以利用公式：
• 如果 n 是奇数，则可以进一步分解为 。
• 对于 n 为负数的情况，可以转换为 。

来看完整的题解：

class Solution {

    // 处理 n 为负数的情况        long N = n; // 解决 -Integer.MAX_VALUE 溢出的情况。        if (N < 0) {            x = 1 / x;            N = -N;        }        return fastPow(x, N);    }
// 递归实现快速幂    private double fastPow(double x, long n) {        // 基本情况：当 n 为 0 时，x^0 = 1        if (n == 0) {            return 1.0;        }
    // 递归计算 x^(n/2)，将 n 除以 2 来缩小问题规模        double half = fastPow(x, n / 2);
    // 如果 n 是偶数，x^n = (x^(n/2)) * (x^(n/2)) = half * half        if (n % 2 == 0) {            return half * half;        }         // 如果 n 是奇数，x^n = x * (x^(n/2)) * (x^(n/2)) = half * half * x        else {            return half * half * x;        }    }
public static void main(String[] args) {        Solution solution = new Solution();        System.out.println(solution.myPow(2.0, 10));  // 输出: 1024.0        System.out.println(solution.myPow(2.1, 3));   // 输出: 9.261        System.out.println(solution.myPow(2.0, -2));  // 输出: 0.25    }}

这次题解效率就高多了。

总结

二进制不仅仅可以用来表示数据，还可以利用它来实现很多算法，提高效率。

这道题的本质是希望我们实现一个 Pow 方法，暴力算法的题解效率比较低，所以要用快速幂算法。

力扣链接：https://leetcode.cn/problems/powx-n/

一步一个脚印

不积跬步无以至千里，不积小流无以成江海。LeetCode - 100天从算法小白到卷王正式启动了，我们计划周一到周五至少每天更新一篇，周六周日更新一篇，目标 300 道 LeetCode 经典题。

PDF 版本目前只针对**二哥编程星球 的球友开放，如果你也想一起打卡学习算法的话，戳链接 **加入我们吧。

一个人可以走得很快，但一群人才能走得更远。二哥编程星球 （目前已有 6300 多名球友加入）里面的每个球友都非常的友善，除了鼓励你，还会给你提出合理的建议，一起冲！

• 语雀专栏地址+密码可通过星球置顶帖查看：https://t.zsxq.com/15rEo9Pdu
• 这道题可以说完全重写了，给出 3 道大家完全都能掌握的题解（主要是二进制和十进制的关系，以及快速幂算法）。
• 增加代码注释，这样大家更容易看懂并掌握题解；
• 增加参考资料，这样大家可以从零基础直接开刷，减轻新手刷题的阻力；
• 增加手绘图，这样大家更容易理解解题思路；
• 增加 ACM 输入输出，这样大家可以在 Intellij IDEA 中进行调试；
• 增加题解模拟，这样大家可以根据题解模拟整个题解过程，看完会有一种“哦哦”恍然大悟的感觉；
• 图片上传至 OSS 并配合 CDN，提升大家在技术派网站中的阅读体感。
• 另外，这一版本会作为 PDF 的终稿随后在星球进行发布。
• 技术派阅读地址：https://paicoding.com/column/7/50

二哥瞎逼逼：人生总是起起伏伏，当你以为自己稳了的时候，冷不丁就会跌入谷底。所以当你取得一些成绩的时候，一定要有敬畏之心，不要张扬。时刻牢记自己就是一个普通人，这样你才会更加长久的生命力。LeetCode 有这么多题，你就是要不停的刷，才有希望举一反三。坚持吧，我们一起努力。

题意

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

难度

中等

示例

示例 1：

输入：x = 2.00000, n = 10

示例 2：

输入：x = 2.10000, n = 3

示例 3：

输入：x = 2.00000, n = -2

解释：2-2 = 1/22 = 1/4 = 0.25

分析 1

在 029.两数相除 中，我们利用了 快速加法 来实现 乘法 ，而Pow(x, n)作为 “乘法Plus版” ，能不能也利用 快速乘法 来实现呢？

当然是可以的！

我们先来考虑二进制拆分，例如7可以用二进制表示为111来表示，转化为十进制就是1 * 1 + 1 * 2 + 1 * 4，那么 就是 ，再例如10可以用二进制表示1010来表示，再转化为十进制就是0 * 1 + 1 * 2 + 0 * 4 + 1 * 8，那么 就可以变成 。

对十进制和二进制之间转化还没有概念的球友可以看看**B 站上这个视频 **，讲的很清晰：

截图来自B 站的三乐大掌柜

发现了没？

我们只需要计算n在二进制表示下，1的位上相应的x的幂即可，然后再将它们相乘即可。

可是这又引出了另外一个问题——总不能从1依次到n算出每个二进制位上对应的幂吧？

实际上并不用这么麻烦，既然用到二进制了，就要善于利用二进制的特性！！！

二进制下的每一位，其实对应着上一位的两倍。假如我们计算的是x的幂，其实计算的是上一位的 平方 。

当n为负数怎么处理呢？

实际上是从 变成了 的情况，所以还是只需要计算出 ，然后再用 1 除以结果即可。

来看题解方法：

class Solution {

    // 判断 n 的正负，如果 n > 0 则 f = 1，否则 f = -1        int f = n > 0 ? 1 : -1;
    // 使用 long 类型存储 n 的绝对值，避免 n 是 Integer.MIN_VALUE 时溢出        long up = n;        up = Math.abs(up);
    // 初始化结果为 1        double res = 1;
    // 快速幂：逐位处理 n 的二进制表示        while (up > 0) {            // 如果当前的二进制位为 1，那么将当前的 x 乘到结果中            if ((up & 1) == 1) { // 位与运算，检查二进制位的最低位是否为 1                res = res * x;            }
        // 每次将 x 平方（相当于 n 除以 2），从而将幂次的处理往下移一位            x = x * x;
        // 右移 up，相当于对 n 的二进制进行右移一位，处理下一位            up >>= 1;        }
    // 如果 n 是正数则直接返回结果，如果 n 是负数则返回 1.0 / res        return f == 1 ? res : 1.0 / res;    }}

来看一下题解效率，还不错，很高，直接击败了 100% 的 Java 提交：

分析 2

分析 1 中我们用了位运算，这对于有些初学算法的球友来说，可能并不是很友好，那有没有更简单一点的题解思路呢？

有，直接调用 Java 提供的 Math.pow 方法，直接返回结果即可，哈哈哈哈😄。

class Solution {

    return Math.pow(x, n);    }}

来看一下题解效率，仍然 beat 100%。说真的，Java 的强大之处就在于此，当别的语言需要实现很复杂的算法时，JDK 早为你提供了，直接调用就好了。

只不过该方法是一个 native 方法，不然可以看看它是怎么实现的。

分析 3

当然了，这道题的本质还是希望我们自己去实现一个 Pow 方法，最直接的暴力算法就是循环 n 次，然后累乘就好了：

public double pow(double x, int n) {

for (int i = 0; i < n; i++) {        res *= x;    }    return res;}

不过我们还需要考虑一些边界情况，比如 n 为负数的情况，这时候我们需要将 x 变为 1/x，然后再将 n 变为正数，这样就可以直接调用上面的方法了。

class Solution {

// 计算 x 的 n 次幂函数    public double myPow(double x, int n) {        // 如果 n 为 0，根据指数规则，任何数的 0 次幂都为 1        if (n == 0) {            return 1;        }
    // 如果 n 为负数，将 x 取倒数并将 n 转为正数        if (n < 0) {            x = 1 / x;  // 负指数转换为倒数            n = -n;     // 将 n 转为正数（此处可能会出现溢出风险）        }
    // 计算 x^n，调用辅助函数 pow        return pow(x, n);    }
// 辅助函数，计算 x 的 n 次幂    public double pow(double x, int n) {        double res = 1; // 初始化结果为 1（x^0 = 1）                // 循环 n 次，每次将 x 乘入结果 res 中，逐步累积 x 的 n 次幂        for (int i = 0; i < n; i++) {            res *= x;        }
    // 返回最终计算的结果        return res;    }}

可惜的是超出时间限制了。

for 循环的时间复杂度为 O(n)，我们可以使用快速幂算法来将时间复杂度优化为 O(log n)。

快速幂的核心思想是指数折半，我们可以将 拆分成更小的问题来解决。

• 如果 n 是偶数，可以利用公式：
• 如果 n 是奇数，则可以进一步分解为 。
• 对于 n 为负数的情况，可以转换为 。

来看完整的题解：

class Solution {

    // 处理 n 为负数的情况        long N = n; // 解决 -Integer.MAX_VALUE 溢出的情况。        if (N < 0) {            x = 1 / x;            N = -N;        }        return fastPow(x, N);    }
// 递归实现快速幂    private double fastPow(double x, long n) {        // 基本情况：当 n 为 0 时，x^0 = 1        if (n == 0) {            return 1.0;        }
    // 递归计算 x^(n/2)，将 n 除以 2 来缩小问题规模        double half = fastPow(x, n / 2);
    // 如果 n 是偶数，x^n = (x^(n/2)) * (x^(n/2)) = half * half        if (n % 2 == 0) {            return half * half;        }         // 如果 n 是奇数，x^n = x * (x^(n/2)) * (x^(n/2)) = half * half * x        else {            return half * half * x;        }    }
public static void main(String[] args) {        Solution solution = new Solution();        System.out.println(solution.myPow(2.0, 10));  // 输出: 1024.0        System.out.println(solution.myPow(2.1, 3));   // 输出: 9.261        System.out.println(solution.myPow(2.0, -2));  // 输出: 0.25    }}

这次题解效率就高多了。

总结

二进制不仅仅可以用来表示数据，还可以利用它来实现很多算法，提高效率。

这道题的本质是希望我们实现一个 Pow 方法，暴力算法的题解效率比较低，所以要用快速幂算法。

力扣链接：https://leetcode.cn/problems/powx-n/

一步一个脚印

不积跬步无以至千里，不积小流无以成江海。LeetCode - 100天从算法小白到卷王正式启动了，我们计划周一到周五至少每天更新一篇，周六周日更新一篇，目标 300 道 LeetCode 经典题。

PDF 版本目前只针对**二哥编程星球 的球友开放，如果你也想一起打卡学习算法的话，戳链接 **加入我们吧。

一个人可以走得很快，但一群人才能走得更远。二哥编程星球 （目前已有 6300 多名球友加入）里面的每个球友都非常的友善，除了鼓励你，还会给你提出合理的建议，一起冲！

• 语雀专栏地址+密码可通过星球置顶帖查看：https://t.zsxq.com/15rEo9Pdu

• 这道题可以说完全重写了，给出 3 道大家完全都能掌握的题解（主要是二进制和十进制的关系，以及快速幂算法）。

• 增加代码注释，这样大家更容易看懂并掌握题解；

• 增加参考资料，这样大家可以从零基础直接开刷，减轻新手刷题的阻力；

• 增加手绘图，这样大家更容易理解解题思路；

• 增加 ACM 输入输出，这样大家可以在 Intellij IDEA 中进行调试；

• 增加题解模拟，这样大家可以根据题解模拟整个题解过程，看完会有一种“哦哦”恍然大悟的感觉；

• 图片上传至 OSS 并配合 CDN，提升大家在技术派网站中的阅读体感。

• 另外，这一版本会作为 PDF 的终稿随后在星球进行发布。

• 技术派阅读地址：https://paicoding.com/column/7/50

            知识星球
  
  
  
  
        扫码加入星球
        查看更多优质内容
  
    https://wx.zsxq.com/mweb/views/joingroup/join_group.html?group_id=15522885221412