算法的时间复杂度

Question

这是我按升序对列表进行排序的代码。我在函数中使用了函数。现在我想计算这个函数的时间复杂度。从我的角度来看，我计算出每次函数“sort”完成其循环时都会调用函数“unite”。所以这个函数每次都要用到两个函数。所以我得出结论，这个函数的复杂度是 O(nlog(n))。 我是本章的新手。所以我想知道如何计算这种复杂度。上面的答案只是我的近似值。我既不知道真正的答案，也没有任何解决方案或提示。因此，请在您给予时描述您的答案。 谢谢。 这是我的代码。

def sort(lst):
    def unite(l1, l2):
        if len(l1) == 0:
            return l2
        elif len(l2) == 0:
            return l1
        elif l1[0] < l2[0]:
            return [l1[0]] + unite(l1[1:], l2)
        else:
            return [l2[0]] + unite(l1, l2[1:])

    if len(lst) == 0 or len(lst) == 1:
        return lst
    else:
        front = sort(lst[:len(lst)/2])
        back = sort(lst[len(lst)/2:])

        L = lst[:]  # the next 3 questions below refer to this line
        return unite(front, back)

Answer 1

第一步是要注意真正的工作是在代码的unite 步骤中完成的，n^2 工作是因为您每次都在创建新列表。

因此，您实际上可以为您的函数正在执行的工作量编写一个快速重现：

W(n) = 2W(n/2) + n^2

因为您在长度为 n/2 的列表上递归了两次，并通过 n^2 重新加入它们。

现在，考虑一个递归树 - 在树的某个级别（称为级别 i），您正在做 2^i * (n/2^i)^2 的工作。这就是每个级别的O(n^2) 工作，还有log(n) 级别，所以你正在做O(n^2log(n)) 工作。

但是，有一种方法可以编写您的 unite 函数，使其运行得更快，在 O(n) 时间。在这种情况下，您会（通过与上述类似的分析）O(nlog(n)) 工作。

Answer 2

sort 在 n 元素向量上执行的时间是 T(n)。

T(n) =  2 T(n/2) + n

     =  2 [2 T(n/4) + n/2] + n

     =  4 T(n/4) + 2n

     = 4 [2 T(n/8) + n/4] + 2n

     = 8 T(n/8) + 3n
     ........

     = 2k T(n/2k) + k n

     = 2log2 n T(1) + (log2n) n   because T(1)=O(1) 

     = n + n log2 n    

     = O(n log n) 

有一种简单的方法可以记住排序解决方案递归函数的复杂性。 T（选择排序）= O（n ^ 2），并且T（合并排序）= O（nlogn）。显然，您的代码是合并排序类型。

Answer 3

上述代码的时间复杂度（不是空间复杂度）为O(nlog(n))。

开始时列表中有n 元素，我们每次将n/2 元素中的列表递归地划分为front 和back，这使其成为O(log(n)) 步骤。 现在，对于O(log(n)) 的每个步骤，我们只在unite 函数中迭代l1 和l2 中的每个元素一次，这使得unite 函数O(n) 变得复杂。

因此，对于O(log(n)) 的除法和O(n) 联合步骤使该算法的时间复杂度为O(nlog(n))。

其他答案正在讨论unite函数的空间复杂度O(n^2)，但问题标题明确询问时间复杂度而不是空间复杂度。