# `heapq` — Heap queue algorithm

Вихідний код: Lib/heapq.py

Цей модуль забезпечує реалізацію алгоритму черги купи, також відомого як алгоритм пріоритетної черги.

Min-heaps are binary trees for which every parent node has a value less than or equal to any of its children. We refer to this condition as the heap invariant.

For min-heaps, this implementation uses lists for which `heap[k] <= heap[2*k+1]` and `heap[k] <= heap[2*k+2]` for all k for which the compared elements exist. Elements are counted from zero. The interesting property of a min-heap is that its smallest element is always the root, `heap[0]`.

Max-heaps satisfy the reverse invariant: every parent node has a value greater than any of its children. These are implemented as lists for which `maxheap[2*k+1] <= maxheap[k]` and `maxheap[2*k+2] <= maxheap[k]` for all k for which the compared elements exist. The root, `maxheap[0]`, contains the largest element; `heap.sort(reverse=True)` maintains the max-heap invariant.

The `heapq` API differs from textbook heap algorithms in two aspects: (a) We use zero-based indexing. This makes the relationship between the index for a node and the indexes for its children slightly less obvious, but is more suitable since Python uses zero-based indexing. (b) Textbooks often focus on max-heaps, due to their suitability for in-place sorting. Our implementation favors min-heaps as they better correspond to Python `lists`.

These two aspects make it possible to view the heap as a regular Python list without surprises: `heap[0]` is the smallest item, and `heap.sort()` maintains the heap invariant!

Like `list.sort()`, this implementation uses only the `<` operator for comparisons, for both min-heaps and max-heaps.

In the API below, and in this documentation, the unqualified term heap generally refers to a min-heap. The API for max-heaps is named using a `_max` suffix.

To create a heap, use a list initialized as `[]`, or transform an existing list into a min-heap or max-heap using the `heapify()` or `heapify_max()` functions, respectively.

The following functions are provided for min-heaps:

heapq.heapify(x)

  Transform list x into a min-heap, in-place, in linear time.

heapq.heappush(heap, item)

  Push the value item onto the heap, maintaining the min-heap invariant.

heapq.heappop(heap)

  Pop and return the smallest item from the heap, maintaining the min-heap invariant. If the heap is empty, `IndexError` is raised. To access the smallest item without popping it, use `heap[0]`.

heapq.heappushpop(heap, item)

  Натисніть item на купу, а потім витягніть і поверніть найменший елемент із купи. Комбінована дія працює ефективніше, ніж `heappush()`, після якого слід окремий виклик `heappop()`.

heapq.heapreplace(heap, item)

  Витягніть і поверніть найменший предмет із купи, а також натисніть новий предмет. Розмір купи не змінюється. Якщо купа порожня, виникає `IndexError`.

  Ця одноетапна операція є ефективнішою, ніж `heappop()`, за якою слідує `heappush()`, і може бути більш доцільною, якщо використовується купа фіксованого розміру. Комбінація pop/push завжди повертає елемент із купи та замінює його на item.

  Повернене значення може бути більшим за доданий елемент. Якщо це небажано, подумайте про використання замість цього `heappushpop()`. Його комбінація push/pop повертає менше з двох значень, залишаючи більше значення в купі.

For max-heaps, the following functions are provided:

heapq.heapify_max(x)

  Transform list x into a max-heap, in-place, in linear time.

  Added in version 3.14.

heapq.heappush_max(heap, item)

  Push the value item onto the max-heap heap, maintaining the max-heap invariant.

  Added in version 3.14.

heapq.heappop_max(heap)

  Pop and return the largest item from the max-heap heap, maintaining the max-heap invariant. If the max-heap is empty, `IndexError` is raised. To access the largest item without popping it, use `maxheap[0]`.

  Added in version 3.14.

heapq.heappushpop_max(heap, item)

  Push item on the max-heap heap, then pop and return the largest item from heap. The combined action runs more efficiently than `heappush_max()` followed by a separate call to `heappop_max()`.

  Added in version 3.14.

heapq.heapreplace_max(heap, item)

  Pop and return the largest item from the max-heap heap and also push the new item. The max-heap size doesn’t change. If the max-heap is empty, `IndexError` is raised.

  The value returned may be smaller than the item added. Refer to the analogous function `heapreplace()` for detailed usage notes.

  Added in version 3.14.

Модуль також пропонує три функції загального призначення, засновані на купах.

heapq.merge(*iterables, key=None, reverse=False)

  Об’єднайте кілька відсортованих вхідних даних в один відсортований вихід (наприклад, об’єднайте записи з мітками часу з кількох файлів журналу). Повертає iterator над відсортованими значеннями.

  Подібно до `sorted(itertools.chain(*iterables))`, але повертає iterable, не затягує дані в пам’ять усі одночасно та передбачає, що кожен із вхідних потоків уже відсортовано (від найменшого до найбільшого).

  Має два необов’язкові аргументи, які необхідно вказати як аргументи ключового слова.

  key визначає key function одного аргументу, який використовується для отримання ключа порівняння з кожного вхідного елемента. Значення за замовчуванням – `None` (пряме порівняння елементів).

  reverse — це логічне значення. Якщо встановлено значення `True`, то вхідні елементи об’єднуються так, ніби кожне порівняння було зворотним. Щоб досягти поведінки, подібної до `sorted(itertools.chain(*iterables), reverse=True)`, усі ітератори мають бути відсортовані від найбільшого до найменшого.

  Змінено в версії 3.5: Додано додаткові параметри key і reverse.

heapq.nlargest(n, iterable, key=None)

  Повертає список із n найбільшими елементами з набору даних, визначеного iterable. key, якщо надається, визначає функцію одного аргументу, який використовується для отримання ключа порівняння з кожного елемента в iterable (наприклад, `key=str.lower`). Еквівалент: `sorted(iterable, key=key, reverse=True)[:n]`.

heapq.nsmallest(n, iterable, key=None)

  Повертає список із n найменшими елементами з набору даних, визначеного iterable. key, якщо надається, визначає функцію одного аргументу, який використовується для отримання ключа порівняння з кожного елемента в iterable (наприклад, `key=str.lower`). Еквівалент: `sorted(iterable, key=key)[:n]`.

Дві останні функції працюють найкраще для менших значень n. Для більших значень ефективніше використовувати функцію `sorted()`. Крім того, коли `n==1`, ефективніше використовувати вбудовані функції `min()` і `max()`. Якщо потрібне повторне використання цих функцій, подумайте про те, щоб перетворити iterable на справжню купу.

## Основні приклади

heapsort може бути реалізовано шляхом переміщення всіх значень у купу, а потім вилучення найменших значень по одному:

    >>> def heapsort(iterable):
    ...     h = []
    ...     for value in iterable:
    ...         heappush(h, value)
    ...     return [heappop(h) for i in range(len(h))]
    ...
    >>> heapsort([1, 3, 5, 7, 9, 2, 4, 6, 8, 0])
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Це схоже на `sorted(iterable)`, але на відміну від `sorted()`, ця реалізація не є стабільною.

Елементи купи можуть бути кортежами. Це корисно для призначення порівняльних значень (наприклад, пріоритетів завдань) поряд із основним записом, який відстежується:

    >>> h = []
    >>> heappush(h, (5, 'write code'))
    >>> heappush(h, (7, 'release product'))
    >>> heappush(h, (1, 'write spec'))
    >>> heappush(h, (3, 'create tests'))
    >>> heappop(h)
    (1, 'write spec')

## Other Applications

Medians are a measure of central tendency for a set of numbers. In distributions skewed by outliers, the median provides a more stable estimate than an average (arithmetic mean). A running median is an online algorithm that updates continuously as new data arrives.

A running median can be efficiently implemented by balancing two heaps, a max-heap for values at or below the midpoint and a min-heap for values above the midpoint. When the two heaps have the same size, the new median is the average of the tops of the two heaps; otherwise, the median is at the top of the larger heap:

    def running_median(iterable):
        "Yields the cumulative median of values seen so far."

        lo = []  # max-heap
        hi = []  # min-heap (same size as or one smaller than lo)

        for x in iterable:
            if len(lo) == len(hi):
                heappush_max(lo, heappushpop(hi, x))
                yield lo[0]
            else:
                heappush(hi, heappushpop_max(lo, x))
                yield (lo[0] + hi[0]) / 2

For example:

    >>> list(running_median([5.0, 9.0, 4.0, 12.0, 8.0, 9.0]))
    [5.0, 7.0, 5.0, 7.0, 8.0, 8.5]

## Примітки щодо реалізації пріоритетної черги

Пріоритетна черга зазвичай використовується для купи, і це створює кілька проблем реалізації:

- Стабільність сортування: як повернути два завдання з однаковими пріоритетами в тому порядку, в якому вони були спочатку додані?

- Порівняння кортежу розривається для пар (пріоритет, завдання), якщо пріоритети рівні, а завдання не мають порядку порівняння за замовчуванням.

- Якщо пріоритет завдання змінюється, як перемістити його на нове місце в купі?

- Або якщо завдання, що очікує на виконання, потрібно видалити, як його знайти та видалити з черги?

Рішенням перших двох проблем є збереження записів у вигляді списку з 3 елементів, включаючи пріоритет, кількість записів і завдання. Підрахунок записів служить вирішальним, щоб два завдання з однаковим пріоритетом поверталися в порядку їх додавання. А оскільки немає двох однакових підрахунків записів, порівняння кортежів ніколи не намагатиметься безпосередньо порівняти два завдання.

Іншим вирішенням проблеми непорівнюваних завдань є створення класу-оболонки, який ігнорує елемент завдання та порівнює лише поле пріоритету:

    from dataclasses import dataclass, field
    from typing import Any

    @dataclass(order=True)
    class PrioritizedItem:
        priority: int
        item: Any=field(compare=False)

Проблеми, що залишилися, пов’язані з пошуком незавершеного завдання та внесенням змін до його пріоритету або його повним видаленням. Знайти завдання можна за допомогою словника, який вказує на запис у черзі.

Видалити запис або змінити його пріоритет складніше, оскільки це порушить інваріанти структури купи. Отже, можливим рішенням є позначення запису як видаленого та додавання нового запису зі зміненим пріоритетом:

    pq = []                         # list of entries arranged in a heap
    entry_finder = {}               # mapping of tasks to entries
    REMOVED = '<removed-task>'      # placeholder for a removed task
    counter = itertools.count()     # unique sequence count

    def add_task(task, priority=0):
        'Add a new task or update the priority of an existing task'
        if task in entry_finder:
            remove_task(task)
        count = next(counter)
        entry = [priority, count, task]
        entry_finder[task] = entry
        heappush(pq, entry)

    def remove_task(task):
        'Mark an existing task as REMOVED.  Raise KeyError if not found.'
        entry = entry_finder.pop(task)
        entry[-1] = REMOVED

    def pop_task():
        'Remove and return the lowest priority task. Raise KeyError if empty.'
        while pq:
            priority, count, task = heappop(pq)
            if task is not REMOVED:
                del entry_finder[task]
                return task
        raise KeyError('pop from an empty priority queue')

## Теорія

Купи — це масиви, для яких `a[k] <= a[2*k+1]` і `a[k] <= a[2*k+2]` для всіх k, підрахунок елементів від 0. Для порівняння, неіснуючі елементи вважаються нескінченними. Цікавою властивістю купи є те, що `a[0]` завжди є її найменшим елементом.

The strange invariant above is meant to be an efficient memory representation for a tournament. The numbers below are k, not `a[k]`:

У наведеному вище дереві кожна комірка k є вершиною `2*k+1` і `2*k+2`. У звичайному бінарному турнірі, який ми бачимо у спорті, кожна клітина є переможцем над двома клітинками, які вона очолює, і ми можемо відстежити переможця вниз по дереву, щоб побачити всіх суперників, які він/вона мали. Однак у багатьох комп’ютерних програмах таких турнірів нам не потрібно відстежувати історію переможця. Щоб підвищити ефективність пам’яті, коли переможець підвищується, ми намагаємося замінити його чимось іншим на нижчому рівні, і правило стає таким, що клітинка та дві верхні клітинки містять три різні елементи, але верхня клітинка «перемагає». над двома верхніми клітинами.

If this heap invariant is protected at all time, index 0 is clearly the overall winner. The simplest algorithmic way to remove it and find the «next» winner is to move some loser (let’s say cell 30 in the diagram above) into the 0 position, and then percolate this new 0 down the tree, exchanging values, until the invariant is re-established. This is clearly logarithmic on the total number of items in the tree. By iterating over all items, you get an O(n log n) sort.

Приємною особливістю цього сортування є те, що ви можете ефективно вставляти нові елементи під час сортування, за умови, що вставлені елементи не «кращі», ніж останній нульовий елемент, який ви витягли. Це особливо корисно в контекстах симуляції, де дерево містить усі вхідні події, а умова «виграш» означає найменший запланований час. Коли подія планує інші події для виконання, вони плануються в майбутньому, тому їх можна легко перемістити в купу. Отже, купа є хорошою структурою для реалізації планувальників (це те, що я використовував для свого MIDI-секвенсора :-).

Різноманітні структури для реалізації планувальників були ретельно вивчені, і для цього добре підійдуть купи, оскільки вони досить швидкі, швидкість майже постійна, а найгірший випадок не сильно відрізняється від середнього випадку. Однак існують інші представлення, які в цілому є більш ефективними, але найгірші випадки можуть бути жахливими.

Купи також дуже корисні для сортування великих дисків. Напевно, ви всі знаєте, що велике сортування передбачає створення «запусків» (це попередньо відсортовані послідовності, розмір яких зазвичай пов’язаний з обсягом пам’яті процесора), після чого слід об’єднання проходів для цих запусків, яке часто є дуже спритним. організовано [1]. Дуже важливо, щоб початкове сортування створювало якнайдовші серії. Хорошим способом досягти цього є турніри. Якщо, використовуючи всю пам’ять, доступну для проведення турніру, ви замінюєте та просочуєте елементи, які випадково відповідають поточному циклу, ви створите цикли, які вдвічі перевищують розмір пам’яті для випадкового введення, і набагато краще для нечітко впорядкованого введення.

Більше того, якщо ви виведете 0-й елемент на диску та отримаєте вхідні дані, які можуть не відповідати поточному турніру (оскільки значення «перемагає» над останнім вихідним значенням), воно не може поміститися у купу, тому розмір купа зменшується. Звільнену пам’ять можна негайно використати повторно для поступового створення другої купи, яка росте з тією ж швидкістю, що й перша купа тане. Коли перша купа повністю зникає, ви змінюєте купи та починаєте новий запуск. Розумно і досить ефективно!

Одним словом, купи - це корисні структури пам’яті, які слід знати. Я використовую їх у кількох програмах, і я вважаю, що добре тримати модуль «купи». :-)

Виноски

[1]

Сучасні алгоритми балансування дисків радше дратують, ніж розумні, і це є наслідком можливостей пошуку дисків. На пристроях, які не можуть шукати, як-от великі стрічкові накопичувачі, історія була зовсім іншою, і потрібно було бути дуже кмітливим, щоб переконатися (заздалегідь), що кожен рух стрічки буде максимально ефективним (тобто найкраще братиме участь у « просувається» злиття). Деякі стрічки навіть могли читати назад, і це також використовувалося, щоб уникнути перемотування часу. Повірте, дивитися справді гарні стрічки було дуже вражаюче! З усіх часів сортування завжди було Великим Мистецтвом! :-)