LeetCode刷题--- Pow（x, n）- 快速幂

个人主页：元清加油_【C++】,【C语言】,【数据结构与算法】-CSDN博客

个人专栏：http://t.csdnimg.cn/ZxuNL

                 http://t.csdnimg.cn/c9twt

---

前言：这个专栏主要讲述递归递归、搜索与回溯算法，所以下面题目主要也是这些算法做的  

我讲述题目会把讲解部分分为3个部分：
1、题目解析

2、算法原理思路讲解

3、代码实现

---

一、Pow（x, n）- 快速幂

题目链接：Pow(x, n)

题目：

实现 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
• -231 <= n <= 231-1
• n 是一个整数
• 要么 x 不为零，要么 n > 0 。
• -104 <= xn <= 104

---

二、解法 

题目解析

题目意思非常简单，给你一个数，让你求他的n次幂

我们初看这道题目的时候，可能非常的疑惑，这道题目不是非常简单么?

使用一个while循环即可，就像下面

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

        double a = x;
        n--;
        while (n > 0)
        {
            a *= x;
            n--;
        }
        if (flag == 0)
        {
            return a;
        }
        else
        {
            return 1.0/a;
        }
    }
};

但是我们提交后，我们发现超出时间限制，我们应该减少时间复杂度。

算法原理思路讲解 

注意：我们在做递归这一类题目是要将递归看作一个黑盒，我们不管他是如何实现的，我们就相信他一定可以帮助我们完成目标

递归思路：
1、设计函数头（寻找重复子问题，并且将递归函数看作一个黑盒）。

2、设计函数体（只关心一个子问题，并解决它）

3、设计函数出口（递归的终止条件）
 

算法思路：

给我一个数，让我求他的n次幂，如果我们直接暴力查找的话，循环的次数太多，时间复杂度太高

那我们可不可以减少算的次数呢？答案是可以的？

（以下的^是某数的几次幂的意思，不是异或）

例如：2^4

我们可以用（2^2）*（2^2）来替代，而(2^2)可以使用（2^1）*（2^1）* 2 替代了，下面就可以以此类推了

这样我们就可以每次将n次幂除以二，再将两数相乘，这样就有了重复子问题。

这样我们可以使用递归了，下面我们来设计递归

1、设计函数头

求出 x 的 n 次⽅是多少，然后返回

double pow(double x, long long n)

2、设计函数体（只关心一个子问题，并解决它）

1、先求出 x 的 n / 2 次⽅是多少

2、然后根据 n 的奇偶，得出 x 的 n 次⽅是多少

double tmp = pow(x, n / 2);
return n % 2 == 0 ? tmp * tmp : tmp * tmp * x;

3、设计函数出口

当 n 为 0 的时候，返回 1 即可。

if(n == 0) return 1.0;

我们做完这些后，还有一个问题，那就是n有可能为负数，n为负数我们又该如何呢？

我们在数学中应该都知道，n为负数的话，那么结果就是n次幂的倒数

那我们就可以

1、将n变成正数

2、求出n次幂的结果

3、再用1.0除以结果即可

这样就可以解决这个问题了

以上思路就讲解完了，大家可以先自己先做一下

---

• 时间复杂度：O(log⁡n)，即为递归的层数。
• 空间复杂度：O(log⁡n)，即为递归的层数。这是由于递归的函数调用会使用栈空间。

代码实现 

class Solution 
{
public:
    double pow(double x, long long n)
    {
        if(n == 0) return 1.0;
        double tmp = pow(x, n / 2);
        return n % 2 == 0 ? tmp * tmp : tmp * tmp * x;
    }
    
    double myPow(double x, int n) 
    {
        return n < 0 ? 1.0 / pow(x, -(long long)n) : pow(x, n);
    }
    
};