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

Материал из Викиконспекты
Версия от 01:32, 16 июня 2014; Alexey Katsman (обсуждение | вклад) (Добавление нового элемента)
Перейти к: навигация, поиск

Определение

Определение:
Двоичная куча или пирамида — такое двоичное подвешенное дерево, для которого выполнены следующие три условия:
  • Значение в любой вершине не меньше, (если куча для максимума), чем значения её потомков.
  • На [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].

siftDown

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

siftUp

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

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

function siftUp(i : int):
    while A[i] [math]\lt [/math] A[(i - 1) / 2]     // i [math]==[/math] 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.heapSize - 1]
    A.heapSize = A.heapSize - 1
    siftDown(0)
    return min

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

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

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

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

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


Дан массив [math]A[0.. N - 1].[/math] Требуется построить [math]D[/math]-кучу с минимумом в корне. Наиболее очевидный способ построить такую кучу из неупорядоченного массива — сделать нулевой элемент массива корнем, а дальше по очереди добавить все его элементы в конец кучи и запускать от каждого добавленного элемента [math]\mathrm {siftUp}[/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]\genfrac {}{}{}{}{N}{D}[/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]

См. также

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