This document is for an old version of Python that is no longer supported. You should upgrade, and read the Python documentation for the current stable release.

# `heapq` — Heap queue algorithm

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

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

Heaps are binary trees for which every parent node has a value less than or equal to any of its children. This implementation uses arrays for which `heap[k] <= heap[2*k+1]` and `heap[k] <= heap[2*k+2]` for all k, counting elements from zero. For the sake of comparison, non-existing elements are considered to be infinite. The interesting property of a heap is that its smallest element is always the root, `heap[0]`.

Наведений нижче API відрізняється від алгоритмів купи підручників двома аспектами: (a) ми використовуємо індексування на основі нуля. Це робить зв’язок між індексом для вузла та індексами для його дочірніх елементів дещо менш очевидним, але є більш придатним, оскільки Python використовує індексування від нуля. (b) Наш метод pop повертає найменший елемент, а не найбільший (у підручниках називається «мінімальна купа»; «максимальна купа» більш поширена в текстах через її придатність для сортування на місці).

Ці два параметри дають змогу переглядати купу як звичайний список Python без сюрпризів: `heap[0]` є найменшим елементом, а `heap.sort()` підтримує незмінність купи!

Щоб створити купу, використовуйте список, ініціалізований `[]`, або ви можете перетворити заповнений список на купу за допомогою функції `heapify()`.

Передбачені такі функції:

`heapq.``heappush`(heap, item)

  Перемістіть значення item у купу, зберігаючи незмінність купи.

`heapq.``heappop`(heap)

  Витягніть і поверніть найменший елемент із купи, зберігаючи незмінність купи. Якщо купа порожня, виникає `IndexError`. Щоб отримати доступ до найменшого елемента, не відкриваючи його, використовуйте `heap[0]`.

`heapq.``heappushpop`(heap, item)

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

`heapq.``heapify`(x)

  Перетворення списку x на купу, на місці, за лінійний час.

`heapq.``heapreplace`(heap, item)

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

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

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

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

`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')

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

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

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

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

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

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

Рішенням перших двох проблем є збереження записів у вигляді списку з 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]` завжди є її найменшим елементом.

Дивний інваріант вище призначений для ефективного представлення пам’яті для турніру. Цифри нижче k, а не `a[k]`:

                                   0

                  1                                 2

          3               4                5               6

      7       8       9       10      11      12      13      14

    15 16   17 18   19 20   21 22   23 24   25 26   27 28   29 30

У наведеному вище дереві кожна комірка 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

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