Python 查找最大k整数的时间复杂度是多少？ def max_k_排序（k，nums）： #首先使用timsort对nums进行排序 #添加O（n*log（n））时间复杂度 已排序的\u nums=已排序的（nums） 返回已排序的整数[-1*k:len（整数）] def最大值（k，nums）： #建立初始最大数量列表 max_nums={} #添加O（k）时间复杂度？ i=0 而我最小值\最大值： 最大值[最小值最大值]=n 最小值最大值key=min（最大值，key=max\nums.get） 最小值=最大值[最小值最大值] 返回最大值（） 打印（最大值（5、[2、8、4、9、0、12、12、6、5]））

我很不确定这段代码的时间复杂性。任务是从未排序的整数数组返回最大k个数。数组中的每个数字都在[0，10000]范围内。我的目标是有一个明显的解决方案max_k_sort（k，nums），它以O（n*log（n））时间复杂度执行任务，还有一个方法max_k（k，nums）以O（n）时间复杂度执行任务时间复杂度，其中n是传递的整数数，k是要查找的最大值数。我不禁想知道是否有方法返回按O（n）时间复杂度排序的最大值

def max_k_sort(k, nums):
    # sort nums first using timsort
    # add O(n*log(n)) time complexity
    sorted_nums = sorted(nums)

    return sorted_nums[-1*k:len(nums)]

def max_k(k, nums):
    # build initial max number list
    max_nums = {}

    # add O(k) time complexity?
    i = 0
    while i < k:
        max_nums[i] = 0
        i += 1

    # add O(n) time complexity?
    least_max_key = min(max_nums, key=max_nums.get)
    least_max = max_nums[least_max_key]

    # add O(n) time complexity?
    for n in nums:
        if n > least_max:
            max_nums[least_max_key] = n
            least_max_key = min(max_nums, key=max_nums.get)
            least_max = max_nums[least_max_key]

    return max_nums.values()

print(max_k(5, [2, 8, 4, 9, 0, 12, 12, 6, 5]))

你做了n次O（k）运算，所以第二个函数的复杂度是O（n*k）

假设您希望以排序的顺序输出，那么在O（n*log（k））中，通过创建一个k大小的堆并将所有内容推到堆上，可以最轻松地完成这项工作。这在

heapq.nlargest

中为您实现

for n in nums:
        if n > least_max:
            max_nums[least_max_key] = n
            least_max_key = min(max_nums, key=max_nums.get) # this is O(k)
            least_max = max_nums[least_max_key]

---

如果您不希望以排序的顺序输出，从技术上讲，这可以在O（n）中完成。（和）在线性时间内找到数组中第k个最大的元素；很容易看出，再通过数组一次，将允许您构建一个包含所有k和更大数字的数组，从而得到总的O（n）.

Python列表排序中列表操作的时间复杂度为O（N logn）

切片为O（k）

因此：

O（k）+O（n logn）是O（n logn），其中O（k）小于O（n logn）

作为一个实际问题，试着为它们计时：

>>> max_k(5, [2, 8, 4, 9, 0, 12, 12, 6, 5])
[12, 12, 9, 8, 6]

印刷品：

import heapq
def max_k1(k, nums):
    nums.sort(reverse=True)
    return nums[0:k]

def max_k2(k, nums):
    return heapq.nlargest(k, nums)    

if __name__ == '__main__':
    import timeit
    for f in (max_k1, max_k2):
        li=[2, 8, 4, 9, 0, 12, 12, 6, 5]
        print f.__name__, timeit.timeit('f(5, li)', setup='from __main__ import f, li')  

因此，排序和切片比heapq快20倍

---

根据评论：

max_k1 0.240165948868
max_k2 4.96488595009

---

“我忍不住想知道是否有一种方法可以返回按O（n）时间复杂度排序的最大值。”-只要你在进行比较，就没有骰子。如果有，你可以传递

k=n

以在O（n）时间内对数组排序，而你不能用O（n）比较来区分n！可能的输入顺序。

max_k

是

O（n）

？我不太确定。那么的

中的
min
呢？另外，您实际上是需要按排序顺序排列的最大k值，还是只需要最大k值？如果您不关心它们的顺序，可以使用O（n）选择第k个最高值，然后为每个元素构建一个数组>=该值。@user2357112，使用选择算法似乎是完美的答案。但如果我们使用选择算法来解决它，我们并没有利用问题陈述给我们的信息，即数字的范围。“数组中的每个数字都在[0，10000]范围内。”“此操作的数学下界是
O（n*log（k））
”-不完全正确。可以在
O（n+k*log（k））
中完成此操作，方法是使用选择算法，如选择第k个最高元素，然后构建一个由前k个元素组成的数组并对其排序。如果数组的顺序不重要，我们可以将其降为
O（n）
time。我认为测试有缺陷。
nums.sort
将
nums
排序到位。因此，从下一次
max_k
，
nums
将已经排序。尝试使用
sorted（nums，reverse=True）[:k]
。除此之外，引用文档，
后两个函数（nlargest，nsmalest）对于较小的n值，执行效果最好。对于较大的值，使用sorted（）函数更有效。此外，当n==1时，使用内置的min（）和max（）更有效函数。如果需要重复使用这些函数，考虑把迭代变成一个实际堆。< /代码>呃，当n很小时，常数因子将占主导地位。当然，当n＝10时，实际实现的函数将获胜。尝试n＝100000，k＝5。@ RoIPPI：绝对同意。
import heapq
def max_k1(k, nums):
    nums.sort(reverse=True)
    return nums[0:k]

def max_k2(k, nums):
    return heapq.nlargest(k, nums)    

if __name__ == '__main__':
    import timeit
    for f in (max_k1, max_k2):
        li=[2, 8, 4, 9, 0, 12, 12, 6, 5]
        print f.__name__, timeit.timeit('f(5, li)', setup='from __main__ import f, li')  

max_k1 0.240165948868
max_k2 4.96488595009

import heapq
def max_k1(k, nums):
    nums.sort(reverse=True)
    return nums[0:k]

def max_k2(k, nums):
    return heapq.nlargest(k, nums)   

def max_k3(k, nums):
    return sorted(nums, reverse=True)[0:k]    

if __name__ == '__main__':
    import timeit
    for f in (max_k1, max_k2, max_k3):
        li=[2, 8, 4, 9, 0, 12, 12, 6, 5]
        print f.__name__, timeit.timeit('f(5, li)', setup='from __main__ import f, li')    

max_k1 0.242296934128
max_k2 4.52635192871
max_k3 0.332237005234