Question

我的问题来自下面的leetcode解决方案，我无法理解为什么它是O(k+(n-k)log(k))。

补充：也许复杂性不是这样，事实上我不知道heappush()和heappop()

的时间复杂性

# O(k+(n-k)lgk) time, min-heap
def findKthLargest(self, nums, k):
    heap = []
    for num in nums:
        heapq.heappush(heap, num)
    for _ in xrange(len(nums)-k):
        heapq.heappop(heap)
    return heapq.heappop(heap)

Answer 1

heapq是二进制堆，具有O（log n）push和O（log n）pop。请参阅heapq source code。

您显示的算法需要O（n log n）将所有项目推送到堆上，然后O（（n-k）log n）找到第k个最大元素。因此复杂性将是O（n log n）。它还需要额外的O（n）空间。

您可以在O（n log k）中执行此操作，使用O（k）额外空间稍微修改算法。我不是Python程序员，所以你必须翻译伪代码：

create a new min-heap
push the first k nums onto the heap
for the rest of the nums:
    if num > heap.peek()
        heap.pop()
        heap.push(num)

// at this point, the k largest items are on the heap.
// The kth largest is the root:

return heap.pop()

这里的关键是堆只包含到目前为止看到的最大项目。如果一个项目小于目前为止看到的第k个最大项目，那么它永远不会被放到堆上。最坏的情况是O（n log k）。

实际上，heapq有一个heapreplace方法，所以你可以替换它：

    if num > heap.peek()
        heap.pop()
        heap.push(num)

与

    if num > heap.peek()
        heap.replace(num)

此外，推送第一个k项的替代方法是创建第一个k项的列表并调用heapify。更优化（但仍然是O（n log k））算法是：

create array of first `k` items
heap = heapify(array)
for remaining nums
    if (num > heap.peek())
        heap.replace(num)
return heap.pop()

您也可以在整个阵列上调用heapify，然后弹出第一个n-k项，然后选择顶部：

heapify(nums)
for i = 0 to n-k
    heapq.heappop(nums)
return heapq.heappop(nums)

这更简单。不确定它是否比我之前的建议更快，但它修改了原始数组。复杂性是O（n）构建堆，然后O（（n-k）log n）为pops。所以它是O（（n-k）log n）。最坏情况O（n log n）。

Answer 2

从@Shivam purbia 的帖子总结：

使用 heaps.heapify() 可以减少时间和空间的复杂性，因为 heaps.heapify() 是 an in-place heapify and costs linear time to run it。
heapq.heappush() 和 heapq.heappop() 都花费 O(logN) 时间复杂度

最终代码会是这样...

import heapq

def findKthLargest(self, nums, k):
    heaps.heapify(nums)            # in-place heapify -> cost O(N) time
    
    for _ in range(len(nums)-k):   # run (N-k) times
        heapq.heappop(heap)        # cost O(logN) time
    return heapq.heappop(heap)

总时间复杂度为O((N - k)logN)
总空间复杂度为O(1)

Answer 3

heapify（）实际上需要线性时间，因为此方法与N次调用heapq.push（）有所不同。

heapq.push（）/ heapq.pop（）需要花费n倍的时间，因为它可以将所有节点调整到给定的高度/水平。

当您在heapify（）中传递数组时，无论节点是最小堆还是最大堆，都要确保该节点的左右子节点已经在维护该堆属性。

您可以看到以下视频： https://www.youtube.com/watch?v=HqPJF2L5h9U

https://www.youtube.com/watch?v=B7hVxCmfPtM

希望这会有所帮助。

heapq库中函数的时间复杂度是多少

3 个答案: