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))时间内运行得更快。在这种情况下，您（通过上述类似的分析）{{1}}工作。

Answer 2

排序在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这使得它{{1} } 脚步。现在，对于每个O(log(n))步骤中，我们遍历每个元素O(log(n))和{{1}在l1功能只有一次，这使得l2功能的复杂性{{1 }}。

因此，对于unite分区和unite联合步骤会使此算法O(n)具有时间复杂度。

其他答案正在讨论O(log(n))函数的空间复杂度O(n)，但问题标题清楚地询问时间复杂性而不是空间复杂性。

算法的时间复杂度

3 个答案: