有人可以为我解释这个递归吗？

Question

我从 leetcode 得到这个代码。

class Solution(object):
    def myPow(self, x, n):
         if n == 0: 
             return 1
         if n == -1: 
             return 1 / x
         return self.myPow(x * x, n / 2) * ([1, x][n % 2])

这段代码用于实现poe(x, n)，在Python中表示x**n。

我想知道为什么它可以实现pow(x, n)。

看起来没有意义……

我明白了

if n == 0: 
and
if n == -1:

但核心代码：

self.myPow(x * x, n / 2) * ([1, x][n % 2])

真的很难理解。

顺便说一句，此代码仅适用于 Python 2.7。如果你想在 Python 3 上测试，你应该改变

myPow(x*x, n / 2) * ([1, x][n % 2])

到

myPow(x*x, n // 2) * ([1, x][n % 2]) 

Answer 1

递归函数是计算一个数字的幂（很可能是整数，非负数或-1，幂），正如您所期望的那样（类似于x = 2.2 和n = 9 ）。

（这似乎是为Python 2.x 编写的（由于n/2 的预期结果是integer 而不是n//2））

最初的returns 是非常简单的数学运算。

 if n == 0: 
     return 1
 if n == -1: 
     return 1 / x

当幂为0，则返回1，然后幂为-1，则返回1/x。

现在下一行包含两个元素：

self.myPow(x * x, n/2)
and
[1, x][n%2]

第一个self.myPow(x * x, n/2) 只是意味着你想通过平方幂数x 将更高的功率（不是0 或-1）变成一半

（很可能通过减少所需的乘法次数来加快计算速度 - 想象一下，如果你有计算 2^58 的情况。通过乘法，你必须将数字乘以 58 次。但如果你每次将其一分为二并递归求解，最终会减少操作数）。

例子：

x^8 = (x^2)^4 = y^4 #thus you reduce the number of operation you need to perform

在这里，您将x^2 作为递归中的下一个参数（即y）并递归执行，直到幂为0 或-1。

下一个是你得到两个除法的模数。这是为了弥补 odd 的情况（即当幂 n 为奇数时）。

[1,x][n%2] #is 1 when n is even, is x when n is odd

如果n 是odd，那么通过执行n/2，你会在这个过程中失去一个x。因此，您必须通过将self.myPow(x * x, n / 2) 与x 相乘来弥补。但是如果你的n 不是奇数（偶数），你不会失去一个x，因此你不需要将结果乘以x，而是乘以1。

举例说明：

x^9 = (x^2)^4 * x #take a look the x here

但是

x^8 = (x^2)^4 * 1 #take a look the 1 here

因此，这个：

[1, x][n % 2]

是将前面的递归乘以1（偶数n）或x（奇数n），相当于三元表达式：

1 if n % 2 == 0 else x

Answer 2

这是分而治之的技术。上面的实现是一种计算幂的快速方法。在每次调用时，都会消除一半的乘法。

假设n是偶数，x^n可以写成如下（如果n是奇数，则需要多乘一次）

x^n = (x^2)^(n/2)
or
x^n = (x^n/2)^2

上面显示的函数实现了第一个版本。实现第二个也很容易（我在下面删除了递归基本案例）

r = self.myPow(x,n/2)
return r * r * ([1, x][n % 2])

Answer 3

正确答案可能在下面

class Solution:
    def myPow(self, x: float, n: int) -> float:

        if n == 0: 
            return 1
        if n > 0:
            return self.myPow(x * x, int(n / 2)) * ([1, x][n % 2])
        else:
            return self.myPow(x * x, int(n / 2)) * ([1, 1/x][n % 2])