Рисунок 8-1 Минимальная куча и максимальная куча
Куча, являясь частным случаем полного двоичного дерева, обладает следующими свойствами. - Узлы самого нижнего уровня заполняются слева, а все остальные уровни заполнены полностью. - Корневой узел двоичного дерева мы называем вершиной кучи, а самый правый узел нижнего уровня - основанием кучи. - Для максимальной (минимальной) кучи значение элемента на вершине, то есть у корневого узла, является максимальным (минимальным). ## 8.1.1 Распространенные операции с кучей Нужно отметить, что многие языки программирования предоставляют не саму кучу, а очередь с приоритетом (priority queue) - абстрактную структуру данных, определяемую как очередь, в которой элементы извлекаются в соответствии с приоритетом. На практике **куча обычно используется для реализации очереди с приоритетом, а максимальная куча эквивалентна очереди с приоритетом, в которой элементы извлекаются по убыванию**. С точки зрения использования очередь с приоритетом и куча могут считаться эквивалентными структурами данных. Поэтому в этой книге мы не будем специально различать их и в дальнейшем будем единообразно называть кучей. Распространенные операции с кучей приведены в таблице 8-1. Конкретные имена методов зависят от языка программирования.Таблица 8-1 Эффективность операций с кучей
Рисунок 8-2 Представление и хранение кучи
Мы можем инкапсулировать формулы отображения индексов в функции, чтобы потом было удобнее ими пользоваться: === "Python" ```python title="my_heap.py" def left(self, i: int) -> int: """Получить индекс левого дочернего узла""" return 2 * i + 1 def right(self, i: int) -> int: """Получить индекс правого дочернего узла""" return 2 * i + 2 def parent(self, i: int) -> int: """Получить индекс родительского узла""" return (i - 1) // 2 # Округление вниз при делении ``` === "C++" ```cpp title="my_heap.cpp" /* Получить индекс левого дочернего узла */ int left(int i) { return 2 * i + 1; } /* Получить индекс правого дочернего узла */ int right(int i) { return 2 * i + 2; } /* Получить индекс родительского узла */ int parent(int i) { return (i - 1) / 2; // Округление вниз при делении } ``` === "Java" ```java title="my_heap.java" /* Получить индекс левого дочернего узла */ int left(int i) { return 2 * i + 1; } /* Получить индекс правого дочернего узла */ int right(int i) { return 2 * i + 2; } /* Получить индекс родительского узла */ int parent(int i) { return (i - 1) / 2; // Округление вниз при делении } ``` === "C#" ```csharp title="my_heap.cs" /* Получить индекс левого дочернего узла */ int Left(int i) { return 2 * i + 1; } /* Получить индекс правого дочернего узла */ int Right(int i) { return 2 * i + 2; } /* Получить индекс родительского узла */ int Parent(int i) { return (i - 1) / 2; // Округление вниз при делении } ``` === "Go" ```go title="my_heap.go" /* Получить индекс левого дочернего узла */ func (h *maxHeap) left(i int) int { return 2*i + 1 } /* Получить индекс правого дочернего узла */ func (h *maxHeap) right(i int) int { return 2*i + 2 } /* Получить индекс родительского узла */ func (h *maxHeap) parent(i int) int { // Округление вниз при делении return (i - 1) / 2 } ``` === "Swift" ```swift title="my_heap.swift" /* Получить индекс левого дочернего узла */ func left(i: Int) -> Int { 2 * i + 1 } /* Получить индекс правого дочернего узла */ func right(i: Int) -> Int { 2 * i + 2 } /* Получить индекс родительского узла */ func parent(i: Int) -> Int { (i - 1) / 2 // Округление вниз при делении } ``` === "JS" ```javascript title="my_heap.js" /* Получить индекс левого дочернего узла */ #left(i) { return 2 * i + 1; } /* Получить индекс правого дочернего узла */ #right(i) { return 2 * i + 2; } /* Получить индекс родительского узла */ #parent(i) { return Math.floor((i - 1) / 2); // Округление вниз при делении } ``` === "TS" ```typescript title="my_heap.ts" /* Получить индекс левого дочернего узла */ left(i: number): number { return 2 * i + 1; } /* Получить индекс правого дочернего узла */ right(i: number): number { return 2 * i + 2; } /* Получить индекс родительского узла */ parent(i: number): number { return Math.floor((i - 1) / 2); // Округление вниз при делении } ``` === "Dart" ```dart title="my_heap.dart" /* Получить индекс левого дочернего узла */ int _left(int i) { return 2 * i + 1; } /* Получить индекс правого дочернего узла */ int _right(int i) { return 2 * i + 2; } /* Получить индекс родительского узла */ int _parent(int i) { return (i - 1) ~/ 2; // Округление вниз при делении } ``` === "Rust" ```rust title="my_heap.rs" /* Получить индекс левого дочернего узла */ fn left(i: usize) -> usize { 2 * i + 1 } /* Получить индекс правого дочернего узла */ fn right(i: usize) -> usize { 2 * i + 2 } /* Получить индекс родительского узла */ fn parent(i: usize) -> usize { (i - 1) / 2 // Округление вниз при делении } ``` === "C" ```c title="my_heap.c" /* Получить индекс левого дочернего узла */ int left(MaxHeap *maxHeap, int i) { return 2 * i + 1; } /* Получить индекс правого дочернего узла */ int right(MaxHeap *maxHeap, int i) { return 2 * i + 2; } /* Получить индекс родительского узла */ int parent(MaxHeap *maxHeap, int i) { return (i - 1) / 2; // Округление вниз } ``` === "Kotlin" ```kotlin title="my_heap.kt" /* Получить индекс левого дочернего узла */ fun left(i: Int): Int { return 2 * i + 1 } /* Получить индекс правого дочернего узла */ fun right(i: Int): Int { return 2 * i + 2 } /* Получить индекс родительского узла */ fun parent(i: Int): Int { return (i - 1) / 2 // Округление вниз при делении } ``` === "Ruby" ```ruby title="my_heap.rb" ### Получить индекс левого дочернего узла ### def left(i) 2 * i + 1 end ### Получить индекс правого дочернего узла ### def right(i) 2 * i + 2 end ### Получить индекс родительского узла ### def parent(i) (i - 1) / 2 # Округление вниз при делении end ``` ### 2. Доступ к элементу на вершине кучи Элемент на вершине кучи - это корневой узел двоичного дерева, то есть первый элемент списка: === "Python" ```python title="my_heap.py" def peek(self) -> int: """Доступ к элементу на вершине кучи""" return self.max_heap[0] ``` === "C++" ```cpp title="my_heap.cpp" /* Доступ к элементу на вершине кучи */ int peek() { return maxHeap[0]; } ``` === "Java" ```java title="my_heap.java" /* Доступ к элементу на вершине кучи */ int peek() { return maxHeap.get(0); } ``` === "C#" ```csharp title="my_heap.cs" /* Доступ к элементу на вершине кучи */ int Peek() { return maxHeap[0]; } ``` === "Go" ```go title="my_heap.go" /* Доступ к элементу на вершине кучи */ func (h *maxHeap) peek() any { return h.data[0] } ``` === "Swift" ```swift title="my_heap.swift" /* Доступ к элементу на вершине кучи */ func peek() -> Int { maxHeap[0] } ``` === "JS" ```javascript title="my_heap.js" /* Доступ к элементу на вершине кучи */ peek() { return this.#maxHeap[0]; } ``` === "TS" ```typescript title="my_heap.ts" /* Доступ к элементу на вершине кучи */ peek(): number { return this.maxHeap[0]; } ``` === "Dart" ```dart title="my_heap.dart" /* Доступ к элементу на вершине кучи */ int peek() { return _maxHeap[0]; } ``` === "Rust" ```rust title="my_heap.rs" /* Доступ к элементу на вершине кучи */ fn peek(&self) -> OptionРисунок 8-3 Шаги добавления элемента в кучу
Пусть общее число узлов равно $n$ , тогда высота дерева равна $O(\log n)$ . Следовательно, максимальное число итераций операции упорядочивания кучи тоже не превышает $O(\log n)$ . Отсюда **временная сложность добавления элемента в кучу равна $O(\log n)$** . Код приведен ниже: === "Python" ```python title="my_heap.py" def push(self, val: int): """Добавление элемента в кучу""" # Добавление узла self.max_heap.append(val) # Просеивание снизу вверх self.sift_up(self.size() - 1) def sift_up(self, i: int): """Начиная с узла i, выполнить просеивание снизу вверх""" while True: # Получение родительского узла для узла i p = self.parent(i) # Завершить heapify, когда «корневой узел уже пройден» или «узел не требует исправления» if p < 0 or self.max_heap[i] <= self.max_heap[p]: break # Поменять два узла местами self.swap(i, p) # Циклическое просеивание вверх i = p ``` === "C++" ```cpp title="my_heap.cpp" /* Добавление элемента в кучу */ void push(int val) { // Добавление узла maxHeap.push_back(val); // Просеивание снизу вверх siftUp(size() - 1); } /* Начиная с узла i, выполнить просеивание снизу вверх */ void siftUp(int i) { while (true) { // Получение родительского узла для узла i int p = parent(i); // Завершить heapify, когда «корневой узел уже пройден» или «узел не требует исправления» if (p < 0 || maxHeap[i] <= maxHeap[p]) break; // Поменять два узла местами swap(maxHeap[i], maxHeap[p]); // Циклическое просеивание вверх i = p; } } ``` === "Java" ```java title="my_heap.java" /* Добавление элемента в кучу */ void push(int val) { // Добавление узла maxHeap.add(val); // Просеивание снизу вверх siftUp(size() - 1); } /* Начиная с узла i, выполнить просеивание снизу вверх */ void siftUp(int i) { while (true) { // Получение родительского узла для узла i int p = parent(i); // Завершить heapify, когда «корневой узел уже пройден» или «узел не требует исправления» if (p < 0 || maxHeap.get(i) <= maxHeap.get(p)) break; // Поменять два узла местами swap(i, p); // Циклическое просеивание вверх i = p; } } ``` === "C#" ```csharp title="my_heap.cs" /* Добавление элемента в кучу */ void Push(int val) { // Добавление узла maxHeap.Add(val); // Просеивание снизу вверх SiftUp(Size() - 1); } /* Начиная с узла i, выполнить просеивание снизу вверх */ void SiftUp(int i) { while (true) { // Получение родительского узла для узла i int p = Parent(i); // Если «выход за пределы корневого узла» или «узел не требует исправления», завершить просеивание if (p < 0 || maxHeap[i] <= maxHeap[p]) break; // Поменять два узла местами Swap(i, p); // Циклическое просеивание вверх i = p; } } ``` === "Go" ```go title="my_heap.go" /* Добавление элемента в кучу */ func (h *maxHeap) push(val any) { // Добавление узла h.data = append(h.data, val) // Просеивание снизу вверх h.siftUp(len(h.data) - 1) } /* Начиная с узла i, выполнить просеивание снизу вверх */ func (h *maxHeap) siftUp(i int) { for true { // Получение родительского узла для узла i p := h.parent(i) // Завершить heapify, когда «корневой узел уже пройден» или «узел не требует исправления» if p < 0 || h.data[i].(int) <= h.data[p].(int) { break } // Поменять два узла местами h.swap(i, p) // Циклическое просеивание вверх i = p } } ``` === "Swift" ```swift title="my_heap.swift" /* Добавление элемента в кучу */ func push(val: Int) { // Добавление узла maxHeap.append(val) // Просеивание снизу вверх siftUp(i: size() - 1) } /* Начиная с узла i, выполнить просеивание снизу вверх */ func siftUp(i: Int) { var i = i while true { // Получение родительского узла для узла i let p = parent(i: i) // Завершить heapify, когда «корневой узел уже пройден» или «узел не требует исправления» if p < 0 || maxHeap[i] <= maxHeap[p] { break } // Поменять два узла местами swap(i: i, j: p) // Циклическое просеивание вверх i = p } } ``` === "JS" ```javascript title="my_heap.js" /* Добавление элемента в кучу */ push(val) { // Добавление узла this.#maxHeap.push(val); // Просеивание снизу вверх this.#siftUp(this.size() - 1); } /* Начиная с узла i, выполнить просеивание снизу вверх */ #siftUp(i) { while (true) { // Получение родительского узла для узла i const p = this.#parent(i); // Завершить heapify, когда «корневой узел уже пройден» или «узел не требует исправления» if (p < 0 || this.#maxHeap[i] <= this.#maxHeap[p]) break; // Поменять два узла местами this.#swap(i, p); // Циклическое просеивание вверх i = p; } } ``` === "TS" ```typescript title="my_heap.ts" /* Добавление элемента в кучу */ push(val: number): void { // Добавление узла this.maxHeap.push(val); // Просеивание снизу вверх this.siftUp(this.size() - 1); } /* Начиная с узла i, выполнить просеивание снизу вверх */ siftUp(i: number): void { while (true) { // Получение родительского узла для узла i const p = this.parent(i); // Завершить heapify, когда «корневой узел уже пройден» или «узел не требует исправления» if (p < 0 || this.maxHeap[i] <= this.maxHeap[p]) break; // Поменять два узла местами this.swap(i, p); // Циклическое просеивание вверх i = p; } } ``` === "Dart" ```dart title="my_heap.dart" /* Добавление элемента в кучу */ void push(int val) { // Добавление узла _maxHeap.add(val); // Просеивание снизу вверх siftUp(size() - 1); } /* Начиная с узла i, выполнить просеивание снизу вверх */ void siftUp(int i) { while (true) { // Получение родительского узла для узла i int p = _parent(i); // Завершить heapify, когда «корневой узел уже пройден» или «узел не требует исправления» if (p < 0 || _maxHeap[i] <= _maxHeap[p]) { break; } // Поменять два узла местами _swap(i, p); // Циклическое просеивание вверх i = p; } } ``` === "Rust" ```rust title="my_heap.rs" /* Добавление элемента в кучу */ fn push(&mut self, val: i32) { // Добавление узла self.max_heap.push(val); // Просеивание снизу вверх self.sift_up(self.size() - 1); } /* Начиная с узла i, выполнить просеивание снизу вверх */ fn sift_up(&mut self, mut i: usize) { loop { // Если узел i уже является вершиной кучи, завершить просеивание if i == 0 { break; } // Получение родительского узла для узла i let p = Self::parent(i); // Когда «узел не требует исправления», завершить просеивание if self.max_heap[i] <= self.max_heap[p] { break; } // Поменять два узла местами self.swap(i, p); // Циклическое просеивание вверх i = p; } } ``` === "C" ```c title="my_heap.c" /* Добавление элемента в кучу */ void push(MaxHeap *maxHeap, int val) { // По умолчанию не следует добавлять так много узлов if (maxHeap->size == MAX_SIZE) { printf("heap is full!"); return; } // Добавление узла maxHeap->data[maxHeap->size] = val; maxHeap->size++; // Просеивание снизу вверх siftUp(maxHeap, maxHeap->size - 1); } /* Начиная с узла i, выполнить просеивание снизу вверх */ void siftUp(MaxHeap *maxHeap, int i) { while (true) { // Получение родительского узла для узла i int p = parent(maxHeap, i); // Завершить heapify, когда «корневой узел уже пройден» или «узел не требует исправления» if (p < 0 || maxHeap->data[i] <= maxHeap->data[p]) { break; } // Поменять два узла местами swap(maxHeap, i, p); // Циклическое просеивание вверх i = p; } } ``` === "Kotlin" ```kotlin title="my_heap.kt" /* Добавление элемента в кучу */ fun push(_val: Int) { // Добавление узла maxHeap.add(_val) // Просеивание снизу вверх siftUp(size() - 1) } /* Начиная с узла i, выполнить просеивание снизу вверх */ fun siftUp(it: Int) { // Параметры функций в Kotlin неизменяемы, поэтому создается временная переменная var i = it while (true) { // Получение родительского узла для узла i val p = parent(i) // Завершить heapify, когда «корневой узел уже пройден» или «узел не требует исправления» if (p < 0 || maxHeap[i] <= maxHeap[p]) break // Поменять два узла местами swap(i, p) // Циклическое просеивание вверх i = p } } ``` === "Ruby" ```ruby title="my_heap.rb" ### Добавление элемента в кучу ### def push(val) # Добавление узла @max_heap << val # Просеивание снизу вверх sift_up(size - 1) end ### Начиная с узла i, выполнить просеивание снизу вверх ### def sift_up(i) loop do # Получение родительского узла для узла i p = parent(i) # Завершить heapify, когда «корневой узел уже пройден» или «узел не требует исправления» break if p < 0 || @max_heap[i] <= @max_heap[p] # Поменять два узла местами swap(i, p) # Циклическое просеивание вверх i = p end end ``` ??? pythontutor "Визуализация кода" ### 4. Извлечение элемента с вершины кучи Элемент на вершине кучи - это корневой узел двоичного дерева, то есть первый элемент списка. Если просто удалить первый элемент списка, то индексы всех узлов двоичного дерева изменятся, и это сильно затруднит последующее восстановление структуры при помощи упорядочивания кучи. Чтобы по возможности минимизировать изменение индексов элементов, мы используем следующий порядок действий. 1. Поменять местами элемент на вершине кучи и элемент у основания кучи, то есть поменять корневой узел с самым правым листовым узлом. 2. После обмена удалить основание кучи из списка. Стоит отметить, что, поскольку обмен уже выполнен, фактически удаляется исходный элемент вершины кучи. 3. Начиная от корневого узла, **выполнить упорядочивание кучи сверху вниз**. Как показано на рисунке 8-4, **направление операции упорядочивания кучи сверху вниз противоположно операции упорядочивания кучи снизу вверх**. Мы сравниваем значение корневого узла со значениями двух дочерних узлов, выбираем больший дочерний узел и меняем его местами с корневым узлом. Затем циклически повторяем ту же операцию, пока не выйдем за листовой узел или не встретим узел, который уже не требует обмена. === "<1>" { class="animation-figure" } === "<2>" { class="animation-figure" } === "<3>" { class="animation-figure" } === "<4>" { class="animation-figure" } === "<5>" { class="animation-figure" } === "<6>" { class="animation-figure" } === "<7>" { class="animation-figure" } === "<8>" { class="animation-figure" } === "<9>" { class="animation-figure" } === "<10>" { class="animation-figure" }Рисунок 8-4 Шаги извлечения элемента с вершины кучи
Как и операция добавления в кучу, операция извлечения элемента с вершины кучи также имеет временную сложность $O(\log n)$ . Код приведен ниже: === "Python" ```python title="my_heap.py" def pop(self) -> int: """Извлечение элемента из кучи""" # Обработка пустого случая if self.is_empty(): raise IndexError("куча пуста") # Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы) self.swap(0, self.size() - 1) # Удаление узла val = self.max_heap.pop() # Просеивание сверху вниз self.sift_down(0) # Вернуть элемент с вершины кучи return val def sift_down(self, i: int): """Начиная с узла i, выполнить просеивание сверху вниз""" while True: # Определить узел с максимальным значением среди i, l и r и обозначить его как ma l, r, ma = self.left(i), self.right(i), i if l < self.size() and self.max_heap[l] > self.max_heap[ma]: ma = l if r < self.size() and self.max_heap[r] > self.max_heap[ma]: ma = r # Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти if ma == i: break # Поменять два узла местами self.swap(i, ma) # Циклическое просеивание вниз i = ma ``` === "C++" ```cpp title="my_heap.cpp" /* Извлечение элемента из кучи */ void pop() { // Обработка пустого случая if (isEmpty()) { throw out_of_range("куча пуста"); } // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы) swap(maxHeap[0], maxHeap[size() - 1]); // Удаление узла maxHeap.pop_back(); // Просеивание сверху вниз siftDown(0); } /* Начиная с узла i, выполнить просеивание сверху вниз */ void siftDown(int i) { while (true) { // Определить узел с максимальным значением среди i, l и r и обозначить его как ma int l = left(i), r = right(i), ma = i; if (l < size() && maxHeap[l] > maxHeap[ma]) ma = l; if (r < size() && maxHeap[r] > maxHeap[ma]) ma = r; // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти if (ma == i) break; swap(maxHeap[i], maxHeap[ma]); // Циклическое просеивание вниз i = ma; } } ``` === "Java" ```java title="my_heap.java" /* Извлечение элемента из кучи */ int pop() { // Обработка пустого случая if (isEmpty()) throw new IndexOutOfBoundsException(); // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы) swap(0, size() - 1); // Удаление узла int val = maxHeap.remove(size() - 1); // Просеивание сверху вниз siftDown(0); // Вернуть элемент с вершины кучи return val; } /* Начиная с узла i, выполнить просеивание сверху вниз */ void siftDown(int i) { while (true) { // Определить узел с максимальным значением среди i, l и r и обозначить его как ma int l = left(i), r = right(i), ma = i; if (l < size() && maxHeap.get(l) > maxHeap.get(ma)) ma = l; if (r < size() && maxHeap.get(r) > maxHeap.get(ma)) ma = r; // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти if (ma == i) break; // Поменять два узла местами swap(i, ma); // Циклическое просеивание вниз i = ma; } } ``` === "C#" ```csharp title="my_heap.cs" /* Извлечение элемента из кучи */ int Pop() { // Обработка пустого случая if (IsEmpty()) throw new IndexOutOfRangeException(); // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы) Swap(0, Size() - 1); // Удаление узла int val = maxHeap.Last(); maxHeap.RemoveAt(Size() - 1); // Просеивание сверху вниз SiftDown(0); // Вернуть элемент с вершины кучи return val; } /* Начиная с узла i, выполнить просеивание сверху вниз */ void SiftDown(int i) { while (true) { // Определить узел с максимальным значением среди i, l и r и обозначить его как ma int l = Left(i), r = Right(i), ma = i; if (l < Size() && maxHeap[l] > maxHeap[ma]) ma = l; if (r < Size() && maxHeap[r] > maxHeap[ma]) ma = r; // Если «узел i максимален» или «выход за пределы листовых узлов», завершить просеивание if (ma == i) break; // Поменять два узла местами Swap(i, ma); // Циклическое просеивание вниз i = ma; } } ``` === "Go" ```go title="my_heap.go" /* Извлечение элемента из кучи */ func (h *maxHeap) pop() any { // Обработка пустого случая if h.isEmpty() { fmt.Println("error") return nil } // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы) h.swap(0, h.size()-1) // Удаление узла val := h.data[len(h.data)-1] h.data = h.data[:len(h.data)-1] // Просеивание сверху вниз h.siftDown(0) // Вернуть элемент с вершины кучи return val } /* Начиная с узла i, выполнить просеивание сверху вниз */ func (h *maxHeap) siftDown(i int) { for true { // Определить узел с максимальным значением среди i, l и r и обозначить его как max l, r, max := h.left(i), h.right(i), i if l < h.size() && h.data[l].(int) > h.data[max].(int) { max = l } if r < h.size() && h.data[r].(int) > h.data[max].(int) { max = r } // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти if max == i { break } // Поменять два узла местами h.swap(i, max) // Циклическое просеивание вниз i = max } } ``` === "Swift" ```swift title="my_heap.swift" /* Извлечение элемента из кучи */ func pop() -> Int { // Обработка пустого случая if isEmpty() { fatalError("куча пуста") } // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы) swap(i: 0, j: size() - 1) // Удаление узла let val = maxHeap.remove(at: size() - 1) // Просеивание сверху вниз siftDown(i: 0) // Вернуть элемент с вершины кучи return val } /* Начиная с узла i, выполнить просеивание сверху вниз */ func siftDown(i: Int) { var i = i while true { // Определить узел с максимальным значением среди i, l и r и обозначить его как ma let l = left(i: i) let r = right(i: i) var ma = i if l < size(), maxHeap[l] > maxHeap[ma] { ma = l } if r < size(), maxHeap[r] > maxHeap[ma] { ma = r } // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти if ma == i { break } // Поменять два узла местами swap(i: i, j: ma) // Циклическое просеивание вниз i = ma } } ``` === "JS" ```javascript title="my_heap.js" /* Извлечение элемента из кучи */ pop() { // Обработка пустого случая if (this.isEmpty()) throw new Error('куча пуста'); // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы) this.#swap(0, this.size() - 1); // Удаление узла const val = this.#maxHeap.pop(); // Просеивание сверху вниз this.#siftDown(0); // Вернуть элемент с вершины кучи return val; } /* Начиная с узла i, выполнить просеивание сверху вниз */ #siftDown(i) { while (true) { // Определить узел с максимальным значением среди i, l и r и обозначить его как ma const l = this.#left(i), r = this.#right(i); let ma = i; if (l < this.size() && this.#maxHeap[l] > this.#maxHeap[ma]) ma = l; if (r < this.size() && this.#maxHeap[r] > this.#maxHeap[ma]) ma = r; // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти if (ma === i) break; // Поменять два узла местами this.#swap(i, ma); // Циклическое просеивание вниз i = ma; } } ``` === "TS" ```typescript title="my_heap.ts" /* Извлечение элемента из кучи */ pop(): number { // Обработка пустого случая if (this.isEmpty()) throw new RangeError('Heap is empty.'); // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы) this.swap(0, this.size() - 1); // Удаление узла const val = this.maxHeap.pop(); // Просеивание сверху вниз this.siftDown(0); // Вернуть элемент с вершины кучи return val; } /* Начиная с узла i, выполнить просеивание сверху вниз */ siftDown(i: number): void { while (true) { // Определить узел с максимальным значением среди i, l и r и обозначить его как ma const l = this.left(i), r = this.right(i); let ma = i; if (l < this.size() && this.maxHeap[l] > this.maxHeap[ma]) ma = l; if (r < this.size() && this.maxHeap[r] > this.maxHeap[ma]) ma = r; // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти if (ma === i) break; // Поменять два узла местами this.swap(i, ma); // Циклическое просеивание вниз i = ma; } } ``` === "Dart" ```dart title="my_heap.dart" /* Извлечение элемента из кучи */ int pop() { // Обработка пустого случая if (isEmpty()) throw Exception('куча пуста'); // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы) _swap(0, size() - 1); // Удаление узла int val = _maxHeap.removeLast(); // Просеивание сверху вниз siftDown(0); // Вернуть элемент с вершины кучи return val; } /* Начиная с узла i, выполнить просеивание сверху вниз */ void siftDown(int i) { while (true) { // Определить узел с максимальным значением среди i, l и r и обозначить его как ma int l = _left(i); int r = _right(i); int ma = i; if (l < size() && _maxHeap[l] > _maxHeap[ma]) ma = l; if (r < size() && _maxHeap[r] > _maxHeap[ma]) ma = r; // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти if (ma == i) break; // Поменять два узла местами _swap(i, ma); // Циклическое просеивание вниз i = ma; } } ``` === "Rust" ```rust title="my_heap.rs" /* Извлечение элемента из кучи */ fn pop(&mut self) -> i32 { // Обработка пустого случая if self.is_empty() { panic!("index out of bounds"); } // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы) self.swap(0, self.size() - 1); // Удаление узла let val = self.max_heap.pop().unwrap(); // Просеивание сверху вниз self.sift_down(0); // Вернуть элемент с вершины кучи val } /* Начиная с узла i, выполнить просеивание сверху вниз */ fn sift_down(&mut self, mut i: usize) { loop { // Определить узел с максимальным значением среди i, l и r и обозначить его как ma let (l, r, mut ma) = (Self::left(i), Self::right(i), i); if l < self.size() && self.max_heap[l] > self.max_heap[ma] { ma = l; } if r < self.size() && self.max_heap[r] > self.max_heap[ma] { ma = r; } // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти if ma == i { break; } // Поменять два узла местами self.swap(i, ma); // Циклическое просеивание вниз i = ma; } } ``` === "C" ```c title="my_heap.c" /* Извлечение элемента из кучи */ int pop(MaxHeap *maxHeap) { // Обработка пустого случая if (isEmpty(maxHeap)) { printf("heap is empty!"); return INT_MAX; } // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы) swap(maxHeap, 0, size(maxHeap) - 1); // Удаление узла int val = maxHeap->data[maxHeap->size - 1]; maxHeap->size--; // Просеивание сверху вниз siftDown(maxHeap, 0); // Вернуть элемент с вершины кучи return val; } /* Начиная с узла i, выполнить просеивание сверху вниз */ void siftDown(MaxHeap *maxHeap, int i) { while (true) { // Определить узел с максимальным значением среди i, l и r и обозначить его как max int l = left(maxHeap, i); int r = right(maxHeap, i); int max = i; if (l < size(maxHeap) && maxHeap->data[l] > maxHeap->data[max]) { max = l; } if (r < size(maxHeap) && maxHeap->data[r] > maxHeap->data[max]) { max = r; } // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти if (max == i) { break; } // Поменять два узла местами swap(maxHeap, i, max); // Циклическое просеивание вниз i = max; } } ``` === "Kotlin" ```kotlin title="my_heap.kt" /* Извлечение элемента из кучи */ fun pop(): Int { // Обработка пустого случая if (isEmpty()) throw IndexOutOfBoundsException() // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы) swap(0, size() - 1) // Удаление узла val _val = maxHeap.removeAt(size() - 1) // Просеивание сверху вниз siftDown(0) // Вернуть элемент с вершины кучи return _val } /* Начиная с узла i, выполнить просеивание сверху вниз */ fun siftDown(it: Int) { // Параметры функций в Kotlin неизменяемы, поэтому создается временная переменная var i = it while (true) { // Определить узел с максимальным значением среди i, l и r и обозначить его как ma val l = left(i) val r = right(i) var ma = i if (l < size() && maxHeap[l] > maxHeap[ma]) ma = l if (r < size() && maxHeap[r] > maxHeap[ma]) ma = r // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти if (ma == i) break // Поменять два узла местами swap(i, ma) // Циклическое просеивание вниз i = ma } } ``` === "Ruby" ```ruby title="my_heap.rb" ### Извлечение элемента из кучи ### def pop # Обработка пустого случая raise IndexError, "куча пуста" if is_empty? # Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы) swap(0, size - 1) # Удаление узла val = @max_heap.pop # Просеивание сверху вниз sift_down(0) # Вернуть элемент с вершины кучи val end ### Начиная с узла i, выполнить просеивание сверху вниз ### def sift_down(i) loop do # Определить узел с максимальным значением среди i, l и r и обозначить его как ma l, r, ma = left(i), right(i), i ma = l if l < size && @max_heap[l] > @max_heap[ma] ma = r if r < size && @max_heap[r] > @max_heap[ma] # Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти break if ma == i # Поменять два узла местами swap(i, ma) # Циклическое просеивание вниз i = ma end end ``` ??? pythontutor "Визуализация кода" ## 8.1.3 Типичные применения кучи - **Очередь с приоритетом**: куча обычно является предпочтительной структурой данных для реализации очереди с приоритетом. Добавление и извлечение элементов имеют временную сложность $O(\log n)$ , а построение кучи - $O(n)$ , и все эти операции выполняются очень эффективно. - **Пирамидальная сортировка**: для заданного набора данных можно построить кучу, а затем непрерывно извлекать из нее элементы, получая отсортированные данные. Однако на практике мы обычно используем более изящную реализацию пирамидальной сортировки. Подробности см. в разделе «Пирамидальная сортировка». - **Получение наибольших $k$ элементов**: это классическая алгоритмическая задача и одновременно типичное применение кучи. Например, выбор 10 самых горячих новостей для списка популярных тем или выбор 10 самых продаваемых товаров.