此功能的运行时间是多少？答案

【问题标题】：What is the running time for this function?此功能的运行时间是多少？
【发布时间】：2013-10-24 17:02:38
【问题描述】：

我在这个函数中有 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的复杂度是多少？

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

【问题讨论】：

对于您的第一个问题：您应该考虑比例。如果你给函数两倍大N 会发生什么？它的执行时间是两倍还是更少？
嗯，我没明白你的意思。我说 log n 是因为 do-while 循环，这是错误的吗？
do-while 循环在复杂性的非递归部分中发挥作用，你做对了那部分。但是为什么你更喜欢log n？ do while 循环执行需要多少步？
它会被执行M次，因为它之前的循环？
哦，你的意思是 M 是常数，它只会是 (Theta(lg n) )？

标签： algorithm runtime big-o time-complexity recurrence

【解决方案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)。

希望这会有所帮助！

【讨论】：