遍历堆积列表

Question

我正在进行蒙特卡罗模拟。作为这项任务的一部分，我生成均匀分布在间隔(0,100) 上的样本。

generate = lambda: uniform(0,100)

当所有最接近的生成点对满足条件时，迭代停止。

check = lambda a,b: True if (b-a)<5 else False

我需要有一些结构来有效地保留所有生成的点并能够按升序遍历它们以在所有后续对上执行check。

Python 中有一个heapq 模块，它支持非常有效的堆结构。我决定使用它。

我遇到了一个问题。我发现这个模块不支持遍历过程。我发现按升序访问堆值的唯一方法是使用heapq.heappop。但它会从堆中删除值。

我找到了解决方法，只是将堆对象复制到新对象中，并在新对象上使用heappop 进行迭代。但是我认为每次迭代都将整个结构复制到内存中并不是很有效。

我还有其他方法可以更有效地做我想做的事情吗？

---

用于说明的简化代码。

import heapq
from random import uniform
from itertools import tee, izip, count
from copy import copy


def pairwise(iterable): #get values from iterator in pairs
    a, b = tee(iterable)
    next(b, None)
    return izip(a, b)


check = lambda a,b: True if (b-a)<5 else False
generate = lambda: uniform(0,100)


def iterate_heap(heap):
    heap = copy(heap) #Here I have to copy the heap to be able to traverse
    try:
        while True:
            yield heapq.heappop(heap)
    except IndexError:
        return


def trial():
    items = []

    for i in count():
        item = generate()
        heapq.heappush(items, item)

        it = iterate_heap(items)
        it = pairwise(it)

        if i>0 and all(check(a,b) for a,b in it): #if i==0 then 'it' returns no values and 'all' returns True
            return i

print "The solution is reached. It took %d iterations." % trial()

paiwise 函数来自here 的配方。

---

更新： 在这个使用heappop 的实现中，每次迭代的复杂度是O(n*log(n))：

复制堆：O(n)

向堆中添加新值：O(log(n))

遍历：n 元素 * O(log(n)) 从堆中弹出每个值 -> O(n*log(n))。

结果：O(n+log(n)+n*log(n)) = O(n*log(n)

但我希望遍历是O(n)，因此产生的复杂度将是O(n)。

顺便说一下，如果我们只使用排序列表，我们需要在每次添加时对列表进行排序，所以O(n*log(n))，但遍历将是n*O(1) -> O(n)。所以，得到的复杂度仍然是O(n*log(n))。

我找到了解决办法。这是使用bisect 模块。找到要添加的位置是O(log(n))。添加到列表中的是O(n)（由于实现，插入到位后的所有值都必须移动）。遍历是O(n)。因此，得到的复杂度为O(n)。

不过，如果有一种方法可以在 Python 中使用堆来解决此任务，我会感到很困惑。

Answer 1

来自python docs：

这两个可以毫无疑问地将堆视为常规 Python 列表：heap[0] 是最小的项，而 heap.sort() 保持堆不变！

您是否有理由不能将堆视为列表并对其进行迭代？

Answer 2

我会在堆上使用 list.sort()。这使堆条件保持不变，并且可以直接迭代底层列表。

FWIW，list.sort 使用的Timsort 算法将利用堆中已经存在的部分排序。

Answer 3

为了记录，在这种情况下，正确的数据结构是 B-Tree。有一个implementation：

 from blist import sortedlist

运行时复杂度尽可能低：O(n*logn) 构建列表，O(n) 迭代。

Answer 4

我做了一些效率计算。

使用bisect 模块可以获得最佳性能： 列表中间的 10000 次插入在我的计算机 (Python 2.7) 上计时 0.037 秒。

使用来自blist 模块的sortedlist 时钟为 0.287 秒，插入次数相同。

使用传统的list 和sort 在每个append 时钟2.796 秒后应用。 （现在Timsort 算法在 Python 中使用，它被认为在几乎排序的列表上非常有效；但事实证明它不如使用 bisect 高效）。

---

我用来进行这些计算的代码：

import bisect
import timeit
import __main__
import blist

N = 10000 #Number of executions
L = 1000 #Length of initial list

def test_f_bisect(a):
    bisect.insort_right(a,500)


def test_f_list_sort(a):
    a.append(500)
    a.sort()


test_f_blist_init = '''
from __main__ import test_f_blist
import blist
a = blist.sortedlist(range({L}))
'''.format(L=L)
def test_f_blist(a):
    a.add(500)


names = dir(__main__)
for name in names:
    attr = getattr(__main__,name)
    if hasattr(attr,'__call__'):
        if name.startswith('test_f_'):
            init_name = name + '_init'
            if hasattr(__main__, init_name):
                init = getattr(__main__,init_name)
            else:
                init = 'from __main__ import {name}; a = list(range({L}))'.format(name=name, L=L)
            t = timeit.Timer(stmt='{name}(a)'.format(name=name),
                             setup=init)

            time = t.timeit(N)
            print('{name}: {time}'.format(name=name,time=time))

Answer 5

我创建了一个迭代器类，它将执行最小堆的惰性按顺序遍历。它具有以下优点：

1. 不需要原始堆的副本
2. 不修改原始堆
3. 如果提早停止，延迟迭代会更有效

为了跟踪下一个迭代项，我实际上只是使用了另一个堆 self.next_items。

import heapq

class HeapIter:

    def __init__(self, heap):
        self.original_heap = heap
        self.next_items = []
        if len(self.original_heap) > 0:
            self.next_items.append((self.original_heap[0], 0))

    def current_element(self):
        if len(self.next_items) == 0:
            return None
        return self.next_items[0][0]

    def next(self):
        if len(self.next_items) == 0:
            return None
        next_elem, next_index = heapq.heappop(self.next_items)
        child_1 = 2 * next_index + 1
        child_2 = child_1 + 1
        if child_1 < len(self.original_heap):
            heapq.heappush(self.next_items, (self.original_heap[child_1], child_1))
        if child_2 < len(self.original_heap):
            heapq.heappush(self.next_items, (self.original_heap[child_2], child_2))
        return next_elem