Двоичная куча

Определение

Определение:

Двоичная куча или пирамида — такое двоичное подвешенное дерево, для которого выполнены следующие три условия: Значение в любой вершине не меньше, (если куча для максимума), чем значения её потомков. На [math]i[/math]-ом слое [math]2^i[/math] вершин, кроме последнего. Слои нумеруются с нуля. Последний слой заполнен слева направо (как показано на рисунке)

Пример кучи для максимума

Удобнее всего двоичную кучу хранить в виде массива [math]A[0..n-1][/math], у которого нулевой элемент, [math]A[0][/math] — элемент в корне, а потомками элемента [math]A[i][/math] являются [math]A[2i+1][/math] и [math]A[2i+2][/math]. Высота кучи определяется как высота двоичного дерева. То есть она равна количеству рёбер в самом длинном простом пути, соединяющем корень кучи с одним из её листьев. Высота кучи есть [math]O(\log{N})[/math], где [math]N[/math] — количество узлов дерева.

Чаще всего используют кучи для минимума (когда предок не больше детей) и для максимума (когда предок не меньше детей).

Двоичные кучи используют, например, для того, чтобы извлекать минимум из набора чисел за [math]O(\log{N})[/math]. Они являются частным случаем приоритетных очередей.

Базовые процедуры

Восстановление свойств кучи

Если в куче изменяется один из элементов, то она может перестать удовлетворять свойству упорядоченности. Для восстановления этого свойства служат процедуры [math] \mathrm {siftDown} [/math] (просеивание вниз) и [math] \mathrm {siftUp} [/math] (просеивание вверх). Если значение измененного элемента увеличивается, то свойства кучи восстанавливаются функцией [math] \mathrm {siftDown} [/math]. Работа процедуры: если [math]i[/math]-й элемент меньше, чем его сыновья, всё поддерево уже является кучей, и делать ничего не надо. В противном случае меняем местами [math]i[/math]-й элемент с наименьшим из его сыновей, после чего выполняем [math] \mathrm {siftDown} [/math] для этого сына. Процедура выполняется за время [math]O(\log{N})[/math].

function siftDown(i : int):
    while 2 * i + 1 < A.heapSize     // [math]heapSize[/math] — количество элементов в куче
        left = A[2 * i + 1]     // left — левый сын
        if 2 * i + 2 < A.heapSize and A[2 * i + 2] <= left and A[2 * i + 2] < A[i]     // A[2 * i + 2] — правый сын
            swap(A[2 * i + 2], A[i])
            i = 2 * i + 2
        else
            swap(A[2 * i + 1], A[i])
            i = 2 * i + 1

Если значение измененного элемента уменьшается, то свойства кучи восстанавливаются функцией [math] \mathrm {siftUp} [/math].

Работа процедуры: если элемент больше своего отца, условие 1 соблюдено для всего дерева, и больше ничего делать не нужно. Иначе, мы меняем местами его с отцом. После чего выполняем [math] \mathrm {siftUp} [/math] для этого отца. Иными словами, слишком большой элемент всплывает наверх. Процедура выполняется за время [math]O(\log{N})[/math].

function siftUp(i : int):
    while A[i] < A[(i - 1) / 2]     // i == 0 — мы в корне
        swap(A[i], A[(i - 1) / 2])
        i = (i - 1) / 2

Извлечение минимального элемента

Выполняет извлечение минимального элемента из кучи за время [math]O(\log{N})[/math]. Извлечение выполняется в четыре этапа:

1. Значение корневого элемента (он и является минимальным) сохраняется для последующего возврата.
2. Последний элемент копируется в корень, после чего удаляется из кучи.
3. Вызывается [math] \mathrm {siftDown} [/math] для корня.
4. Сохранённый элемент возвращается.

int extractMin():
  int min = A[0]
  A[0] = A[A.heap_size - 1]
  A.heap_size = A.heap_size - 1
  siftDown(0)
  return min

Добавление нового элемента

Выполняет добавление элемента в кучу за время [math]O(\log{N})[/math]. Добавление произвольного элемента в конец кучи, и восстановление свойства упорядоченности с помощью процедуры [math] \mathrm {siftUp} [/math].

function insert(key : int):
  A.heap_size = A.heap_size + 1
  A[A.heap_size - 1] = key
  siftUp(A.heap_size - 1)

Построение кучи за O(N)

Определение:

[math]D[/math]-куча — это куча, в которой у каждого элемента, кроме, возможно, элементов на последнем уровне, ровно [math]D[/math] потомков.

Дан массив [math]A[0.. N - 1].[/math] Требуется построить [math]D[/math]-кучу с минимумом в корне. Наиболее очевидный способ построить такую кучу из неупорядоченного массива - по очереди добавить все его элементы (сделать [math] \mathrm {siftDown} [/math] для каждого). Временная оценка такого алгоритма [math] O(N\log{N})[/math]. Однако можно построить кучу еще быстрее — за [math] O(N) [/math]. Представим, что в массиве хранится дерево ([math]A[0] - [/math] корень, а потомками элемента [math]A[i][/math] являются [math]A[2i+1]...A[2i+D][/math]). Сделаем [math] \mathrm {siftDown} [/math] для вершин, имеющих хотя бы одного потомка, начиная с конца (от [math] n - 1[/math] до [math]0[/math]) (так как поддеревья, состоящие из одной вершины без потомков, уже упорядочены).

Лемма:

На выходе получим искомую кучу.

Доказательство:

[math]\triangleright[/math]

При вызове [math] \mathrm {siftDown} [/math] для вершины, ее поддеревья являются кучами, после выполнения [math] \mathrm {siftDown} [/math] эта вершина с ее поддеревьями будут также являться кучей. Значит, после выполнения всех [math] \mathrm {siftDown} [/math] получится куча.

[math]\triangleleft[/math]

Лемма:

Время работы этого алгоритма [math] O(N) [/math].

Доказательство:

[math]\triangleright[/math]

Число вершин на высоте [math]h[/math] в куче из [math]N[/math] элементов не превосходит [math] \left \lceil \frac{N}{D^h} \right \rceil [/math]. Высота кучи не превосходит [math] \log_{D}N [/math]. Обозначим за [math] H [/math] высоту дерева, тогда время построения не превосходит [math] \sum_{h = 1}^H \limits\frac{N}{D^h} \cdot D [/math] [math] \cdot h [/math] [math] = N \cdot D \cdot {\sum_{h = 1}^H \limits}\frac{h}{D^h}. [/math] Докажем вспомогательную лемму о сумме ряда. Лемма: [math] {\sum_{h = 1}^\infty \limits}\frac{h}{D^h} = \frac{D}{(D - 1)^2} . [/math] Доказательство: [math]\triangleright[/math] Обозначим за [math]S[/math] сумму ряда. Заметим, что [math] \frac{n}{D^n} = \frac{1}{D} \cdot \frac{n - 1}{D ^{n - 1}} + \frac{1}{D^n}. [/math] [math]{\sum_{n = 1}^\infty \limits}\frac{1}{d^n}[/math] — это сумма бесконечной убывающей геометрической прогрессии, и она равна [math] \frac{\frac{1}{D}}{1 - \frac{1}{D}} = \frac{1}{D - 1}. [/math] Получаем [math]S[/math] [math]=\frac{1}{D}[/math] [math]\cdot S +[/math] [math] \frac{1}{D - 1}. [/math] Откуда [math]S[/math] [math] = \frac{D}{(D - 1)^2}. [/math] [math]\triangleleft[/math] Подставляя в нашу формулу результат леммы, получаем [math]N[/math] [math]\cdot (\frac {D}{D - 1})^2 [/math] [math] \leqslant 4 \cdot N [/math] [math]=O(N).[/math]

[math]\triangleleft[/math]

Источники информации

• Википедия — Двоичная куча
• Википедия — Очередь с приоритетом
• Wikipedia — Binary heap
• Wikipedia — Priority queue