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

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数x使更高的功率（不是0或-1 ）变成一半

（最有可能通过减少所需的乘法次数来加快计算的速度-想象一下如果有大小写的情况下要计算2^58通过乘法，您必须将数字乘以58倍。但是，如果每次将其除以2并求解递归的话，您最终将获得较少的操作）。

例：

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

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

下一个是得到除以2的幂的模。 这是为了弥补奇数情况（即，当幂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])