Question

我在这个函数中有3个问题，

Sum = 0 
MyFunction (N)
        M = 1,000,000 
        If (N > 1)
                For I = 1 to M do
                        Sum = 0
                        J = 1 
                        Do 
                                Sum = Sum + J
                                J = J + 2
                        While J < N 
                End For
                If (MyFunction(N / 2) % 3 == 0)
                        Return (2 * MyFunction(N / 2))
                Else
                        Return (4 * MyFunction(N / 2))
                End If
        Else
                Return 1        
        End If
End MyFunction

第一个问题是：代码的非递归部分的复杂性是什么？

我认为非递归部分是循环

For I = 1 to M do
                        Sum = 0
                        J = 1 
                        Do 
                                Sum = Sum + J
                                J = J + 2
                        While J < N 
                End For

我的答案是M * log(n)，但我的幻灯片说它不是M * log (n)！我需要解释一下。

第二个问题是：以前的MyFunction代码的正确重现是什么？

当我看到这些代码行时

If (MyFunction(N / 2) % 3 == 0)
                        Return (2 * MyFunction(N / 2))
                Else
                        Return (4 * MyFunction(N / 2))
                End If

我认为它是T(n) = T(n/2) + Theta(non-recursive)，因为if会执行2次调用之一。

这个答案再次错了。

第三个是： MyFunction的复杂性是什么？

我基于这2个问题的答案是T(n) = T(n/2) + M * lg n 总运行时间为M * lg n。

Answer 1

让我们一次看一下。

首先，这是代码的非递归部分：

For I = 1 to M do
     Sum = 0
     J = 1 
     Do 
         Sum = Sum + J
         J = J + 2
     While J < N 
End For

外环将运行Θ（M）次。由于M是固定常数（一百万），因此循环将运行Θ（1）次。

在循环内部，内部while循环将运行Θ（N）次，因为在每次迭代时J增加2并且一旦J满足或超过N就停止。因此，此循环嵌套完成的总工作是Θ （N）：Θ（N）工作Θ（1）次。

现在，让我们来看看这部分：

If (MyFunction(N / 2) % 3 == 0)
    Return (2 * MyFunction(N / 2))
Else
    Return (4 * MyFunction(N / 2))
End If

if语句将对大小为N / 2的输入进行一次递归调用，然后根据结果总是会有第二次递归调用大小N / 2（因为你“没有缓存结果。”

这为运行时提供了以下递归关系：

T（n）= 2T（n / 2）+Θ（n）

使用主定理，这解决了Θ（n log n）。

希望这有帮助！

这个功能的运行时间是多少？

1 个答案: