build

2026-07-14 08:06:06 +00:00 · 2026-03-29 02:26:00 +08:00
parent 63276d36d9
commit 37523d4ceb
118 changed files with 74250 additions and 21 deletions
@@ -0,0 +1,388 @@
+---
+comments: true
+---
+
+# 8.2 &nbsp; Построение кучи
+
+В некоторых случаях мы хотим построить кучу, используя сразу все элементы списка. Этот процесс называется "построением кучи".
+
+## 8.2.1 &nbsp; Реализация через операцию добавления в кучу
+
+Сначала мы создаем пустую кучу, затем обходим список и для каждого элемента по очереди выполняем "операцию добавления в кучу": сначала помещаем элемент в хвост кучи, а затем выполняем для него упорядочивание "снизу вверх".
+
+Каждый раз, когда элемент добавляется в кучу, ее длина увеличивается на единицу. Поскольку узлы последовательно добавляются в двоичное дерево сверху вниз, куча строится "сверху вниз".
+
+Пусть число элементов равно $n$ ; так как каждая операция добавления требует $O(\log{n})$ времени, временная сложность такого построения кучи составляет $O(n \log n)$ .
+
+## 8.2.2 &nbsp; Реализация через обход и упорядочивание
+
+На самом деле можно реализовать и более эффективный способ построения кучи, который состоит из двух шагов.
+
+1. Без изменений добавить все элементы списка в кучу; в этот момент свойства кучи еще не выполняются.
+2. Обойти кучу в обратном порядке, то есть в порядке, обратном обходу по уровням, и по очереди выполнить упорядочивание "сверху вниз" для каждого нелистового узла.
+
+**После того как некоторый узел был упорядочен, поддерево с этим узлом в качестве корня становится корректной подкучей**. А поскольку обход выполняется в обратном порядке, куча строится "снизу вверх".
+
+Причина выбора обратного обхода в том, что он гарантирует: поддеревья ниже текущего узла уже являются корректными подкучами, а значит, упорядочивание текущего узла действительно будет эффективным.
+
+Стоит отметить, что **листовые узлы не имеют дочерних узлов, поэтому они естественным образом являются корректными подкучами и не требуют упорядочивания**. Как показано в коде ниже, последний нелистовой узел является родителем последнего узла, и именно с него мы начинаем обратный обход и упорядочивание:
+
+=== "Python"
+
+    ```python title="my_heap.py"
+    def __init__(self, nums: list[int]):
+        """Конструктор, строящий кучу по входному списку"""
+        # Добавить элементы списка в кучу без изменений
+        self.max_heap = nums
+        # Выполнить heapify для всех узлов, кроме листовых
+        for i in range(self.parent(self.size() - 1), -1, -1):
+            self.sift_down(i)
+    ```
+
+=== "C++"
+
+    ```cpp title="my_heap.cpp"
+    /* Конструктор, строящий кучу по входному списку */
+    MaxHeap(vector<int> nums) {
+        // Добавить элементы списка в кучу без изменений
+        maxHeap = nums;
+        // Выполнить heapify для всех узлов, кроме листовых
+        for (int i = parent(size() - 1); i >= 0; i--) {
+            siftDown(i);
+        }
+    }
+    ```
+
+=== "Java"
+
+    ```java title="my_heap.java"
+    /* Конструктор, строящий кучу по входному списку */
+    MaxHeap(List<Integer> nums) {
+        // Добавить элементы списка в кучу без изменений
+        maxHeap = new ArrayList<>(nums);
+        // Выполнить heapify для всех узлов, кроме листовых
+        for (int i = parent(size() - 1); i >= 0; i--) {
+            siftDown(i);
+        }
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="my_heap.cs"
+    /* Конструктор: построить кучу по входному списку */
+    MaxHeap(IEnumerable<int> nums) {
+        // Добавить элементы списка в кучу без изменений
+        maxHeap = new List<int>(nums);
+        // Выполнить heapify для всех узлов, кроме листовых
+        var size = Parent(this.Size() - 1);
+        for (int i = size; i >= 0; i--) {
+            SiftDown(i);
+        }
+    }
+    ```
+
+=== "Go"
+
+    ```go title="my_heap.go"
+    /* Конструктор, строящий кучу по срезу */
+    func newMaxHeap(nums []any) *maxHeap {
+        // Добавить элементы списка в кучу без изменений
+        h := &maxHeap{data: nums}
+        for i := h.parent(len(h.data) - 1); i >= 0; i-- {
+            // Выполнить heapify для всех узлов, кроме листовых
+            h.siftDown(i)
+        }
+        return h
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="my_heap.swift"
+    /* Конструктор, строящий кучу по входному списку */
+    init(nums: [Int]) {
+        // Добавить элементы списка в кучу без изменений
+        maxHeap = nums
+        // Выполнить heapify для всех узлов, кроме листовых
+        for i in (0 ... parent(i: size() - 1)).reversed() {
+            siftDown(i: i)
+        }
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="my_heap.js"
+    /* Конструктор, создающий пустую кучу или строящий кучу по входному списку */
+    constructor(nums) {
+        // Добавить элементы списка в кучу без изменений
+        this.#maxHeap = nums === undefined ? [] : [...nums];
+        // Выполнить heapify для всех узлов, кроме листовых
+        for (let i = this.#parent(this.size() - 1); i >= 0; i--) {
+            this.#siftDown(i);
+        }
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="my_heap.ts"
+    /* Конструктор, создающий пустую кучу или строящий кучу по входному списку */
+    constructor(nums?: number[]) {
+        // Добавить элементы списка в кучу без изменений
+        this.maxHeap = nums === undefined ? [] : [...nums];
+        // Выполнить heapify для всех узлов, кроме листовых
+        for (let i = this.parent(this.size() - 1); i >= 0; i--) {
+            this.siftDown(i);
+        }
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="my_heap.dart"
+    /* Конструктор, строящий кучу по входному списку */
+    MaxHeap(List<int> nums) {
+      // Добавить элементы списка в кучу без изменений
+      _maxHeap = nums;
+      // Выполнить heapify для всех узлов, кроме листовых
+      for (int i = _parent(size() - 1); i >= 0; i--) {
+        siftDown(i);
+      }
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="my_heap.rs"
+    /* Конструктор, строящий кучу по входному списку */
+    fn new(nums: Vec<i32>) -> Self {
+        // Добавить элементы списка в кучу без изменений
+        let mut heap = MaxHeap { max_heap: nums };
+        // Выполнить heapify для всех узлов, кроме листовых
+        for i in (0..=Self::parent(heap.size() - 1)).rev() {
+            heap.sift_down(i);
+        }
+        heap
+    }
+    ```
+
+=== "C"
+
+    ```c title="my_heap.c"
+    /* Конструктор, строящий кучу по срезу */
+    MaxHeap *newMaxHeap(int nums[], int size) {
+        // Поместить все элементы в кучу
+        MaxHeap *maxHeap = (MaxHeap *)malloc(sizeof(MaxHeap));
+        maxHeap->size = size;
+        memcpy(maxHeap->data, nums, size * sizeof(int));
+        for (int i = parent(maxHeap, size - 1); i >= 0; i--) {
+            // Выполнить heapify для всех узлов, кроме листовых
+            siftDown(maxHeap, i);
+        }
+        return maxHeap;
+    }
+    ```
+
+=== "Kotlin"
+
+    ```kotlin title="my_heap.kt"
+    /* Максимальная куча */
+    class MaxHeap(nums: MutableList<Int>?) {
+        // Использовать список вместо массива, чтобы не учитывать проблему расширения
+        private val maxHeap = mutableListOf<Int>()
+
+        /* Конструктор, строящий кучу по входному списку */
+        init {
+            // Добавить элементы списка в кучу без изменений
+            maxHeap.addAll(nums!!)
+            // Выполнить heapify для всех узлов, кроме листовых
+            for (i in parent(size() - 1) downTo 0) {
+                siftDown(i)
+            }
+        }
+
+        /* Получить индекс левого дочернего узла */
+        private fun left(i: Int): Int {
+            return 2 * i + 1
+        }
+
+        /* Получить индекс правого дочернего узла */
+        private fun right(i: Int): Int {
+            return 2 * i + 2
+        }
+
+        /* Получить индекс родительского узла */
+        private fun parent(i: Int): Int {
+            return (i - 1) / 2 // Округление вниз при делении
+        }
+
+        /* Поменять элементы местами */
+        private fun swap(i: Int, j: Int) {
+            val temp = maxHeap[i]
+            maxHeap[i] = maxHeap[j]
+            maxHeap[j] = temp
+        }
+
+        /* Получение размера кучи */
+        fun size(): Int {
+            return maxHeap.size
+        }
+
+        /* Проверка, пуста ли куча */
+        fun isEmpty(): Boolean {
+            /* Проверка, пуста ли куча */
+            return size() == 0
+        }
+
+        /* Доступ к элементу на вершине кучи */
+        fun peek(): Int {
+            return maxHeap[0]
+        }
+
+        /* Добавление элемента в кучу */
+        fun push(_val: Int) {
+            // Добавление узла
+            maxHeap.add(_val)
+            // Просеивание снизу вверх
+            siftUp(size() - 1)
+        }
+
+        /* Начиная с узла i, выполнить просеивание снизу вверх */
+        private 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
+            }
+        }
+
+        /* Извлечение элемента из кучи */
+        fun pop(): Int {
+            // Обработка пустого случая
+            if (isEmpty()) throw IndexOutOfBoundsException()
+            // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)
+            swap(0, size() - 1)
+            // Удаление узла
+            val _val = maxHeap.removeAt(size() - 1)
+            // Просеивание сверху вниз
+            siftDown(0)
+            // Вернуть элемент с вершины кучи
+            return _val
+        }
+
+        /* Начиная с узла i, выполнить просеивание сверху вниз */
+        private 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
+            }
+        }
+
+        /* Вывести кучу (двоичное дерево) */
+        fun print() {
+            val queue = PriorityQueue { a: Int, b: Int -> b - a }
+            queue.addAll(maxHeap)
+            printHeap(queue)
+        }
+    }
+    ```
+
+=== "Ruby"
+
+    ```ruby title="my_heap.rb"
+  =begin
+  File: my_heap.rb
+  Created Time: 2024-04-19
+  Author: Blue Bean (lonnnnnnner@gmail.com)
+  =end
+
+  require_relative '../utils/print_util'
+
+  # ## Максимальная куча ###
+  class MaxHeap
+    attr_reader :max_heap
+
+    # ## Конструктор, строящий кучу по входному списку ###
+    def initialize(nums)
+      # Добавить элементы списка в кучу без изменений
+      @max_heap = nums
+      # Выполнить heapify для всех узлов, кроме листовых
+      parent(size - 1).downto(0) do |i|
+        sift_down(i)
+      end
+    end
+    ```
+
+??? pythontutor "Визуализация кода"
+
+    <div style="height: 549px; width: 100%;"><iframe class="pythontutor-iframe" src="https://pythontutor.com/iframe-embed.html#code=class%20MaxHeap%3A%0A%0A%20%20%20%20def%20__init__%28self%2C%20nums%3A%20list%5Bint%5D%29%3A%0A%20%20%20%20%20%20%20%20self.max_heap%20%3D%20nums%0A%20%20%20%20%20%20%20%20for%20i%20in%20range%28self.parent%28self.size%28%29%20-%201%29%2C%20-1%2C%20-1%29%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20self.sift_down%28i%29%0A%0A%20%20%20%20def%20left%28self%2C%20i%3A%20int%29%20-%3E%20int%3A%0A%20%20%20%20%20%20%20%20return%202%20%2A%20i%20%2B%201%0A%0A%20%20%20%20def%20right%28self%2C%20i%3A%20int%29%20-%3E%20int%3A%0A%20%20%20%20%20%20%20%20return%202%20%2A%20i%20%2B%202%0A%0A%20%20%20%20def%20parent%28self%2C%20i%3A%20int%29%20-%3E%20int%3A%0A%20%20%20%20%20%20%20%20return%20%28i%20-%201%29%20%2F%2F%202%0A%0A%20%20%20%20def%20swap%28self%2C%20i%3A%20int%2C%20j%3A%20int%29%3A%0A%20%20%20%20%20%20%20%20%28self.max_heap%5Bi%5D%2C%20self.max_heap%5Bj%5D%29%20%3D%20%28self.max_heap%5Bj%5D%2C%20self.max_heap%5Bi%5D%29%0A%0A%20%20%20%20def%20size%28self%29%20-%3E%20int%3A%0A%20%20%20%20%20%20%20%20return%20len%28self.max_heap%29%0A%0A%20%20%20%20def%20sift_down%28self%2C%20i%3A%20int%29%3A%0A%20%20%20%20%20%20%20%20while%20True%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20%28l%2C%20r%2C%20ma%29%20%3D%20%28self.left%28i%29%2C%20self.right%28i%29%2C%20i%29%0A%20%20%20%20%20%20%20%20%20%20%20%20if%20l%20%3C%20self.size%28%29%20and%20self.max_heap%5Bl%5D%20%3E%20self.max_heap%5Bma%5D%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20ma%20%3D%20l%0A%20%20%20%20%20%20%20%20%20%20%20%20if%20r%20%3C%20self.size%28%29%20and%20self.max_heap%5Br%5D%20%3E%20self.max_heap%5Bma%5D%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20ma%20%3D%20r%0A%20%20%20%20%20%20%20%20%20%20%20%20if%20ma%20%3D%3D%20i%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20break%0A%20%20%20%20%20%20%20%20%20%20%20%20self.swap%28i%2C%20ma%29%0A%20%20%20%20%20%20%20%20%20%20%20%20i%20%3D%20ma%0A%27Driver%20Code%27%0Aif%20__name__%20%3D%3D%20%27__main__%27%3A%0A%20%20%20%20max_heap%20%3D%20MaxHeap%28%5B1%2C%202%2C%203%2C%204%2C%205%5D%29&codeDivHeight=472&codeDivWidth=350&cumulative=false&curInstr=4&heapPrimitives=nevernest&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false"> </iframe></div>
+    <div style="margin-top: 5px;"><a href="https://pythontutor.com/iframe-embed.html#code=class%20MaxHeap%3A%0A%0A%20%20%20%20def%20__init__%28self%2C%20nums%3A%20list%5Bint%5D%29%3A%0A%20%20%20%20%20%20%20%20self.max_heap%20%3D%20nums%0A%20%20%20%20%20%20%20%20for%20i%20in%20range%28self.parent%28self.size%28%29%20-%201%29%2C%20-1%2C%20-1%29%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20self.sift_down%28i%29%0A%0A%20%20%20%20def%20left%28self%2C%20i%3A%20int%29%20-%3E%20int%3A%0A%20%20%20%20%20%20%20%20return%202%20%2A%20i%20%2B%201%0A%0A%20%20%20%20def%20right%28self%2C%20i%3A%20int%29%20-%3E%20int%3A%0A%20%20%20%20%20%20%20%20return%202%20%2A%20i%20%2B%202%0A%0A%20%20%20%20def%20parent%28self%2C%20i%3A%20int%29%20-%3E%20int%3A%0A%20%20%20%20%20%20%20%20return%20%28i%20-%201%29%20%2F%2F%202%0A%0A%20%20%20%20def%20swap%28self%2C%20i%3A%20int%2C%20j%3A%20int%29%3A%0A%20%20%20%20%20%20%20%20%28self.max_heap%5Bi%5D%2C%20self.max_heap%5Bj%5D%29%20%3D%20%28self.max_heap%5Bj%5D%2C%20self.max_heap%5Bi%5D%29%0A%0A%20%20%20%20def%20size%28self%29%20-%3E%20int%3A%0A%20%20%20%20%20%20%20%20return%20len%28self.max_heap%29%0A%0A%20%20%20%20def%20sift_down%28self%2C%20i%3A%20int%29%3A%0A%20%20%20%20%20%20%20%20while%20True%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20%28l%2C%20r%2C%20ma%29%20%3D%20%28self.left%28i%29%2C%20self.right%28i%29%2C%20i%29%0A%20%20%20%20%20%20%20%20%20%20%20%20if%20l%20%3C%20self.size%28%29%20and%20self.max_heap%5Bl%5D%20%3E%20self.max_heap%5Bma%5D%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20ma%20%3D%20l%0A%20%20%20%20%20%20%20%20%20%20%20%20if%20r%20%3C%20self.size%28%29%20and%20self.max_heap%5Br%5D%20%3E%20self.max_heap%5Bma%5D%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20ma%20%3D%20r%0A%20%20%20%20%20%20%20%20%20%20%20%20if%20ma%20%3D%3D%20i%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20break%0A%20%20%20%20%20%20%20%20%20%20%20%20self.swap%28i%2C%20ma%29%0A%20%20%20%20%20%20%20%20%20%20%20%20i%20%3D%20ma%0A%27Driver%20Code%27%0Aif%20__name__%20%3D%3D%20%27__main__%27%3A%0A%20%20%20%20max_heap%20%3D%20MaxHeap%28%5B1%2C%202%2C%203%2C%204%2C%205%5D%29&codeDivHeight=800&codeDivWidth=600&cumulative=false&curInstr=4&heapPrimitives=nevernest&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false" target="_blank" rel="noopener noreferrer">Во весь экран ></a></div>
+
+## 8.2.3 &nbsp; Анализ сложности
+
+Теперь попробуем оценить временную сложность второго способа построения кучи.
+
+- Пусть число узлов полного двоичного дерева равно $n$ , тогда число листовых узлов равно $(n + 1) / 2$ , где $/$ означает целочисленное деление вниз. Следовательно, число узлов, которые нужно упорядочивать, равно $(n - 1) / 2$ .
+- В процессе упорядочивания сверху вниз каждый узел в худшем случае может просеяться до листа, поэтому максимальное число итераций равно высоте двоичного дерева $\log n$ .
+
+Перемножив эти два значения, можно получить временную сложность построения кучи $O(n \log n)$ . **Но эта оценка неточна, потому что мы не учли свойство двоичного дерева: на нижних уровнях узлов гораздо больше, чем на верхних**.
+
+Далее выполним более точный расчет. Чтобы упростить вычисления, предположим, что дано "идеальное двоичное дерево" высоты $h$ с числом узлов $n$ ; это предположение не повлияет на корректность результата.
+
+![Число узлов на каждом уровне идеального двоичного дерева](build_heap.assets/heapify_operations_count.png){ class="animation-figure" }
+
+<p align="center"> Рисунок 8-5 &nbsp; Число узлов на каждом уровне идеального двоичного дерева </p>
+
+Как показано на рисунке 8-5, максимальное число итераций упорядочивания "сверху вниз" для некоторого узла равно расстоянию от этого узла до листового узла, а это расстояние как раз и есть "высота узла". Поэтому мы можем просуммировать для каждого уровня выражение "число узлов $\times$ высота узла" и **получить суммарное число итераций упорядочивания для всех узлов**.
+
+$$
+T(h) = 2^0h + 2^1(h-1) + 2^2(h-2) + \dots + 2^{(h-1)}\times1
+$$
+
+Чтобы упростить это выражение, воспользуемся школьными знаниями о последовательностях и сначала умножим $T(h)$ на $2$ :
+
+$$
+\begin{aligned}
+T(h) & = 2^0h + 2^1(h-1) + 2^2(h-2) + \dots + 2^{h-1}\times1 \newline
+2 T(h) & = 2^1h + 2^2(h-1) + 2^3(h-2) + \dots + 2^{h}\times1 \newline
+\end{aligned}
+$$
+
+Используя метод вычитания со сдвигом, вычтем из нижней строки $2 T(h)$ верхнюю строку $T(h)$ , тогда получим:
+
+$$
+2T(h) - T(h) = T(h) = -2^0h + 2^1 + 2^2 + \dots + 2^{h-1} + 2^h
+$$
+
+Из этого выражения видно, что $T(h)$ представляет собой геометрическую прогрессию, поэтому можно напрямую применить формулу суммы и получить временную сложность:
+
+$$
+\begin{aligned}
+T(h) & = 2 \frac{1 - 2^h}{1 - 2} - h \newline
+& = 2^{h+1} - h - 2 \newline
+& = O(2^h)
+\end{aligned}
+$$
+
+Далее, число узлов идеального двоичного дерева высоты $h$ равно $n = 2^{h+1} - 1$ , поэтому несложно получить сложность $O(2^h) = O(n)$ . Из этого вывода следует, что **построение кучи из входного списка имеет временную сложность $O(n)$ , что очень эффективно**.
@@ -0,0 +1,21 @@
+---
+comments: true
+icon: material/family-tree
+---
+
+# Глава 8. &nbsp; Куча
+
+![Куча](../assets/covers/chapter_heap.jpg){ class="cover-image" }
+
+!!! abstract
+
+    Куча похожа на горные вершины: ярусные, волнистые и самые разные по форме.
+    
+    Каждая вершина имеет свою высоту, но самая высокая всегда бросается в глаза первой.
+
+## Содержание главы
+
+- [8.1 &nbsp; Куча](heap.md)
+- [8.2 &nbsp; Построение кучи](build_heap.md)
+- [8.3 &nbsp; Задача Top-K](top_k.md)
+- [8.4 &nbsp; Резюме](summary.md)
@@ -0,0 +1,21 @@
+---
+comments: true
+---
+
+# 8.4 &nbsp; Краткие итоги
+
+### 1. &nbsp; Основные моменты
+
+- Куча представляет собой полное двоичное дерево и делится на максимальную кучу и минимальную кучу. Элемент на вершине максимальной (минимальной) кучи является наибольшим (наименьшим).
+- Очередь с приоритетом определяется как очередь, элементы которой извлекаются в соответствии с приоритетом; обычно ее реализуют с помощью кучи.
+- К основным операциям кучи и их временным сложностям относятся: добавление элемента в кучу $O(\log n)$ , извлечение элемента с вершины кучи $O(\log n)$ и доступ к вершине кучи $O(1)$ .
+- Полное двоичное дерево очень удобно представлять массивом, поэтому кучу обычно тоже хранят в массиве.
+- Операция упорядочивания кучи используется для поддержания свойств кучи и применяется как при добавлении элемента, так и при извлечении элемента.
+- Временную сложность построения кучи из $n$ элементов можно оптимизировать до $O(n)$ , что очень эффективно.
+- Top-k - это классическая алгоритмическая задача, которую можно эффективно решать с помощью кучи за $O(n \log k)$ .
+
+### 2. &nbsp; Q & A
+
+**Q**: Является ли "куча" как структура данных тем же самым понятием, что и "куча" в управлении памятью?
+
+Это не одно и то же, просто у них случайно совпало название. Куча в памяти компьютерной системы является частью динамического распределения памяти: во время выполнения программы она используется для хранения данных. Программа может запросить определенный объем памяти в куче для хранения сложных структур, таких как объекты и массивы. Когда эти данные больше не нужны, память нужно освободить, чтобы не допустить утечек. По сравнению со стековой памятью управление памятью в куче требует большей осторожности, а неправильное использование может привести к утечкам памяти, висячим указателям и другим проблемам.
@@ -0,0 +1,503 @@
+---
+comments: true
+---
+
+# 8.3 &nbsp; Задача Top-k
+
+!!! question
+
+    Дан неупорядоченный массив `nums` длины $n$ . Требуется вернуть наибольшие $k$ элементов массива.
+
+Для этой задачи мы сначала покажем два относительно прямолинейных способа решения, а затем более эффективный способ на основе кучи.
+
+## 8.3.1 &nbsp; Метод 1: выбор через обход
+
+Как показано на рисунке 8-6, можно выполнить $k$ проходов по массиву и на каждом проходе извлекать соответственно $1$-й, $2$-й, $\dots$ , $k$-й по величине элемент; временная сложность такого подхода равна $O(nk)$ .
+
+Этот метод подходит только для случая $k \ll n$ , потому что когда $k$ приближается к $n$ , его временная сложность стремится к $O(n^2)$ , а это уже очень затратно.
+
+![Поиск наибольших k элементов через обход](top_k.assets/top_k_traversal.png){ class="animation-figure" }
+
+<p align="center"> Рисунок 8-6 &nbsp; Поиск наибольших k элементов через обход </p>
+
+!!! tip
+
+    Когда $k = n$ , мы получаем полную упорядоченную последовательность, и в этот момент задача становится эквивалентной алгоритму "сортировка выбором".
+
+## 8.3.2 &nbsp; Метод 2: сортировка
+
+Как показано на рисунке 8-7, можно сначала отсортировать массив `nums` , а затем вернуть его крайние правые $k$ элементов; временная сложность такого метода равна $O(n \log n)$ .
+
+Очевидно, что этот способ "делает слишком много", потому что нам нужно только найти наибольшие $k$ элементов, а сортировать остальные элементы совсем не обязательно.
+
+![Поиск наибольших k элементов через сортировку](top_k.assets/top_k_sorting.png){ class="animation-figure" }
+
+<p align="center"> Рисунок 8-7 &nbsp; Поиск наибольших k элементов через сортировку </p>
+
+## 8.3.3 &nbsp; Метод 3: куча
+
+Задачу Top-k можно решить гораздо эффективнее с помощью кучи, как показано на рисунках ниже.
+
+1. Инициализировать минимальную кучу, у которой вершина содержит наименьший элемент.
+2. Сначала по очереди поместить в кучу первые $k$ элементов массива.
+3. Начиная с элемента номер $k + 1$ , если текущий элемент больше элемента на вершине кучи, то извлечь вершину кучи и поместить в кучу текущий элемент.
+4. После завершения обхода в куче будут храниться как раз наибольшие $k$ элементов.
+
+=== "<1>"
+    ![Поиск наибольших k элементов с помощью кучи](top_k.assets/top_k_heap_step1.png){ class="animation-figure" }
+
+=== "<2>"
+    ![top_k_heap_step2](top_k.assets/top_k_heap_step2.png){ class="animation-figure" }
+
+=== "<3>"
+    ![top_k_heap_step3](top_k.assets/top_k_heap_step3.png){ class="animation-figure" }
+
+=== "<4>"
+    ![top_k_heap_step4](top_k.assets/top_k_heap_step4.png){ class="animation-figure" }
+
+=== "<5>"
+    ![top_k_heap_step5](top_k.assets/top_k_heap_step5.png){ class="animation-figure" }
+
+=== "<6>"
+    ![top_k_heap_step6](top_k.assets/top_k_heap_step6.png){ class="animation-figure" }
+
+=== "<7>"
+    ![top_k_heap_step7](top_k.assets/top_k_heap_step7.png){ class="animation-figure" }
+
+=== "<8>"
+    ![top_k_heap_step8](top_k.assets/top_k_heap_step8.png){ class="animation-figure" }
+
+=== "<9>"
+    ![top_k_heap_step9](top_k.assets/top_k_heap_step9.png){ class="animation-figure" }
+
+<p align="center"> Рисунок 8-8 &nbsp; Поиск наибольших k элементов с помощью кучи </p>
+
+Пример кода приведен ниже:
+
+=== "Python"
+
+    ```python title="top_k.py"
+    def top_k_heap(nums: list[int], k: int) -> list[int]:
+        """Найти k наибольших элементов массива с помощью кучи"""
+        # Инициализация минимальной кучи
+        heap = []
+        # Поместить первые k элементов массива в кучу
+        for i in range(k):
+            heapq.heappush(heap, nums[i])
+        # Начиная с элемента k+1, поддерживать длину кучи равной k
+        for i in range(k, len(nums)):
+            # Если текущий элемент больше элемента на вершине кучи, извлечь вершину кучи и добавить текущий элемент в кучу
+            if nums[i] > heap[0]:
+                heapq.heappop(heap)
+                heapq.heappush(heap, nums[i])
+        return heap
+    ```
+
+=== "C++"
+
+    ```cpp title="top_k.cpp"
+    /* Найти k наибольших элементов массива с помощью кучи */
+    priority_queue<int, vector<int>, greater<int>> topKHeap(vector<int> &nums, int k) {
+        // Инициализация минимальной кучи
+        priority_queue<int, vector<int>, greater<int>> heap;
+        // Поместить первые k элементов массива в кучу
+        for (int i = 0; i < k; i++) {
+            heap.push(nums[i]);
+        }
+        // Начиная с элемента k+1, поддерживать длину кучи равной k
+        for (int i = k; i < nums.size(); i++) {
+            // Если текущий элемент больше элемента на вершине кучи, извлечь вершину кучи и добавить текущий элемент в кучу
+            if (nums[i] > heap.top()) {
+                heap.pop();
+                heap.push(nums[i]);
+            }
+        }
+        return heap;
+    }
+    ```
+
+=== "Java"
+
+    ```java title="top_k.java"
+    /* Найти k наибольших элементов массива с помощью кучи */
+    Queue<Integer> topKHeap(int[] nums, int k) {
+        // Инициализация минимальной кучи
+        Queue<Integer> heap = new PriorityQueue<Integer>();
+        // Поместить первые k элементов массива в кучу
+        for (int i = 0; i < k; i++) {
+            heap.offer(nums[i]);
+        }
+        // Начиная с элемента k+1, поддерживать длину кучи равной k
+        for (int i = k; i < nums.length; i++) {
+            // Если текущий элемент больше элемента на вершине кучи, извлечь вершину кучи и добавить текущий элемент в кучу
+            if (nums[i] > heap.peek()) {
+                heap.poll();
+                heap.offer(nums[i]);
+            }
+        }
+        return heap;
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="top_k.cs"
+    /* Найти k наибольших элементов массива с помощью кучи */
+    PriorityQueue<int, int> TopKHeap(int[] nums, int k) {
+        // Инициализация минимальной кучи
+        PriorityQueue<int, int> heap = new();
+        // Поместить первые k элементов массива в кучу
+        for (int i = 0; i < k; i++) {
+            heap.Enqueue(nums[i], nums[i]);
+        }
+        // Начиная с элемента k+1, поддерживать длину кучи равной k
+        for (int i = k; i < nums.Length; i++) {
+            // Если текущий элемент больше элемента на вершине кучи, извлечь вершину кучи и добавить текущий элемент в кучу
+            if (nums[i] > heap.Peek()) {
+                heap.Dequeue();
+                heap.Enqueue(nums[i], nums[i]);
+            }
+        }
+        return heap;
+    }
+    ```
+
+=== "Go"
+
+    ```go title="top_k.go"
+    /* Найти k наибольших элементов массива с помощью кучи */
+    func topKHeap(nums []int, k int) *minHeap {
+        // Инициализация минимальной кучи
+        h := &minHeap{}
+        heap.Init(h)
+        // Поместить первые k элементов массива в кучу
+        for i := 0; i < k; i++ {
+            heap.Push(h, nums[i])
+        }
+        // Начиная с элемента k+1, поддерживать длину кучи равной k
+        for i := k; i < len(nums); i++ {
+            // Если текущий элемент больше элемента на вершине кучи, извлечь вершину кучи и добавить текущий элемент в кучу
+            if nums[i] > h.Top().(int) {
+                heap.Pop(h)
+                heap.Push(h, nums[i])
+            }
+        }
+        return h
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title="top_k.swift"
+    /* Найти k наибольших элементов массива с помощью кучи */
+    func topKHeap(nums: [Int], k: Int) -> [Int] {
+        // Инициализировать минимальную кучу и построить ее по первым k элементам
+        var heap = Heap(nums.prefix(k))
+        // Начиная с элемента k+1, поддерживать длину кучи равной k
+        for i in nums.indices.dropFirst(k) {
+            // Если текущий элемент больше элемента на вершине кучи, извлечь вершину кучи и добавить текущий элемент в кучу
+            if nums[i] > heap.min()! {
+                _ = heap.removeMin()
+                heap.insert(nums[i])
+            }
+        }
+        return heap.unordered
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title="top_k.js"
+    /* Добавление элемента в кучу */
+    function pushMinHeap(maxHeap, val) {
+        // Инвертировать знак элемента
+        maxHeap.push(-val);
+    }
+
+    /* Извлечение элемента из кучи */
+    function popMinHeap(maxHeap) {
+        // Инвертировать знак элемента
+        return -maxHeap.pop();
+    }
+
+    /* Доступ к элементу на вершине кучи */
+    function peekMinHeap(maxHeap) {
+        // Инвертировать знак элемента
+        return -maxHeap.peek();
+    }
+
+    /* Извлечь элементы из кучи */
+    function getMinHeap(maxHeap) {
+        // Инвертировать знак элемента
+        return maxHeap.getMaxHeap().map((num) => -num);
+    }
+
+    /* Найти k наибольших элементов массива с помощью кучи */
+    function topKHeap(nums, k) {
+        // Инициализация минимальной кучи
+        // Обратите внимание: мы инвертируем все элементы кучи, чтобы с помощью максимальной кучи имитировать минимальную
+        const maxHeap = new MaxHeap([]);
+        // Поместить первые k элементов массива в кучу
+        for (let i = 0; i < k; i++) {
+            pushMinHeap(maxHeap, nums[i]);
+        }
+        // Начиная с элемента k+1, поддерживать длину кучи равной k
+        for (let i = k; i < nums.length; i++) {
+            // Если текущий элемент больше элемента на вершине кучи, извлечь вершину кучи и добавить текущий элемент в кучу
+            if (nums[i] > peekMinHeap(maxHeap)) {
+                popMinHeap(maxHeap);
+                pushMinHeap(maxHeap, nums[i]);
+            }
+        }
+        // Вернуть элементы кучи
+        return getMinHeap(maxHeap);
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title="top_k.ts"
+    /* Добавление элемента в кучу */
+    function pushMinHeap(maxHeap: MaxHeap, val: number): void {
+        // Инвертировать знак элемента
+        maxHeap.push(-val);
+    }
+
+    /* Извлечение элемента из кучи */
+    function popMinHeap(maxHeap: MaxHeap): number {
+        // Инвертировать знак элемента
+        return -maxHeap.pop();
+    }
+
+    /* Доступ к элементу на вершине кучи */
+    function peekMinHeap(maxHeap: MaxHeap): number {
+        // Инвертировать знак элемента
+        return -maxHeap.peek();
+    }
+
+    /* Извлечь элементы из кучи */
+    function getMinHeap(maxHeap: MaxHeap): number[] {
+        // Инвертировать знак элемента
+        return maxHeap.getMaxHeap().map((num: number) => -num);
+    }
+
+    /* Найти k наибольших элементов массива с помощью кучи */
+    function topKHeap(nums: number[], k: number): number[] {
+        // Инициализация минимальной кучи
+        // Обратите внимание: мы инвертируем все элементы кучи, чтобы с помощью максимальной кучи имитировать минимальную
+        const maxHeap = new MaxHeap([]);
+        // Поместить первые k элементов массива в кучу
+        for (let i = 0; i < k; i++) {
+            pushMinHeap(maxHeap, nums[i]);
+        }
+        // Начиная с элемента k+1, поддерживать длину кучи равной k
+        for (let i = k; i < nums.length; i++) {
+            // Если текущий элемент больше элемента на вершине кучи, извлечь вершину кучи и добавить текущий элемент в кучу
+            if (nums[i] > peekMinHeap(maxHeap)) {
+                popMinHeap(maxHeap);
+                pushMinHeap(maxHeap, nums[i]);
+            }
+        }
+        // Вернуть элементы кучи
+        return getMinHeap(maxHeap);
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title="top_k.dart"
+    /* Найти k наибольших элементов массива с помощью кучи */
+    MinHeap topKHeap(List<int> nums, int k) {
+      // Инициализировать минимальную кучу, поместив в нее первые k элементов массива
+      MinHeap heap = MinHeap(nums.sublist(0, k));
+      // Начиная с элемента k+1, поддерживать длину кучи равной k
+      for (int i = k; i < nums.length; i++) {
+        // Если текущий элемент больше элемента на вершине кучи, извлечь вершину кучи и добавить текущий элемент в кучу
+        if (nums[i] > heap.peek()) {
+          heap.pop();
+          heap.push(nums[i]);
+        }
+      }
+      return heap;
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title="top_k.rs"
+    /* Найти k наибольших элементов массива с помощью кучи */
+    fn top_k_heap(nums: Vec<i32>, k: usize) -> BinaryHeap<Reverse<i32>> {
+        // BinaryHeap — это максимальная куча; с помощью Reverse элементы инвертируются, чтобы реализовать минимальную кучу
+        let mut heap = BinaryHeap::<Reverse<i32>>::new();
+        // Поместить первые k элементов массива в кучу
+        for &num in nums.iter().take(k) {
+            heap.push(Reverse(num));
+        }
+        // Начиная с элемента k+1, поддерживать длину кучи равной k
+        for &num in nums.iter().skip(k) {
+            // Если текущий элемент больше элемента на вершине кучи, извлечь вершину кучи и добавить текущий элемент в кучу
+            if num > heap.peek().unwrap().0 {
+                heap.pop();
+                heap.push(Reverse(num));
+            }
+        }
+        heap
+    }
+    ```
+
+=== "C"
+
+    ```c title="top_k.c"
+    /* Добавление элемента в кучу */
+    void pushMinHeap(MaxHeap *maxHeap, int val) {
+        // Инвертировать знак элемента
+        push(maxHeap, -val);
+    }
+
+    /* Извлечение элемента из кучи */
+    int popMinHeap(MaxHeap *maxHeap) {
+        // Инвертировать знак элемента
+        return -pop(maxHeap);
+    }
+
+    /* Доступ к элементу на вершине кучи */
+    int peekMinHeap(MaxHeap *maxHeap) {
+        // Инвертировать знак элемента
+        return -peek(maxHeap);
+    }
+
+    /* Извлечь элементы из кучи */
+    int *getMinHeap(MaxHeap *maxHeap) {
+        // Инвертировать все элементы кучи и записать их в массив res
+        int *res = (int *)malloc(maxHeap->size * sizeof(int));
+        for (int i = 0; i < maxHeap->size; i++) {
+            res[i] = -maxHeap->data[i];
+        }
+        return res;
+    }
+
+    /* Извлечь элементы из кучи */
+    int *getMinHeap(MaxHeap *maxHeap) {
+        // Инвертировать все элементы кучи и записать их в массив res
+        int *res = (int *)malloc(maxHeap->size * sizeof(int));
+        for (int i = 0; i < maxHeap->size; i++) {
+            res[i] = -maxHeap->data[i];
+        }
+        return res;
+    }
+
+    // Функция поиска k наибольших элементов массива на основе кучи
+    int *topKHeap(int *nums, int sizeNums, int k) {
+        // Инициализация минимальной кучи
+        // Обратите внимание: мы инвертируем все элементы кучи, чтобы с помощью максимальной кучи имитировать минимальную
+        int *empty = (int *)malloc(0);
+        MaxHeap *maxHeap = newMaxHeap(empty, 0);
+        // Поместить первые k элементов массива в кучу
+        for (int i = 0; i < k; i++) {
+            pushMinHeap(maxHeap, nums[i]);
+        }
+        // Начиная с элемента k+1, поддерживать длину кучи равной k
+        for (int i = k; i < sizeNums; i++) {
+            // Если текущий элемент больше элемента на вершине кучи, извлечь вершину кучи и добавить текущий элемент в кучу
+            if (nums[i] > peekMinHeap(maxHeap)) {
+                popMinHeap(maxHeap);
+                pushMinHeap(maxHeap, nums[i]);
+            }
+        }
+        int *res = getMinHeap(maxHeap);
+        // Освободить память
+        delMaxHeap(maxHeap);
+        return res;
+    }
+    ```
+
+=== "Kotlin"
+
+    ```kotlin title="top_k.kt"
+    /* Найти k наибольших элементов массива с помощью кучи */
+    fun topKHeap(nums: IntArray, k: Int): Queue<Int> {
+        // Инициализация минимальной кучи
+        val heap = PriorityQueue<Int>()
+        // Поместить первые k элементов массива в кучу
+        for (i in 0..<k) {
+            heap.offer(nums[i])
+        }
+        // Начиная с элемента k+1, поддерживать длину кучи равной k
+        for (i in k..<nums.size) {
+            // Если текущий элемент больше элемента на вершине кучи, извлечь вершину кучи и добавить текущий элемент в кучу
+            if (nums[i] > heap.peek()) {
+                heap.poll()
+                heap.offer(nums[i])
+            }
+        }
+        return heap
+    }
+    ```
+
+=== "Ruby"
+
+    ```ruby title="top_k.rb"
+    =begin
+    File: top_k.rb
+    Created Time: 2024-04-19
+    Author: Blue Bean (lonnnnnnner@gmail.com)
+    =end
+
+    require_relative "./my_heap"
+
+    # ## Добавление элемента в кучу ###
+    def push_min_heap(heap, val)
+      # Инвертировать знак элемента
+      heap.push(-val)
+    end
+
+    # ## Извлечение элемента из кучи ###
+    def pop_min_heap(heap)
+      # Инвертировать знак элемента
+      -heap.pop
+    end
+
+    # ## Доступ к элементу на вершине кучи ###
+    def peek_min_heap(heap)
+      # Инвертировать знак элемента
+      -heap.peek
+    end
+
+    # ## Извлечение элементов из кучи ###
+    def get_min_heap(heap)
+      # Инвертировать все элементы кучи
+      heap.max_heap.map { |x| -x }
+    end
+
+    # ## Поиск k наибольших элементов массива с помощью кучи ###
+    def top_k_heap(nums, k)
+      # Инициализация минимальной кучи
+      # Обратите внимание: мы инвертируем все элементы кучи, чтобы с помощью максимальной кучи имитировать минимальную
+      max_heap = MaxHeap.new([])
+
+      # Поместить первые k элементов массива в кучу
+      for i in 0...k
+        push_min_heap(max_heap, nums[i])
+      end
+
+      # Начиная с элемента k+1, поддерживать длину кучи равной k
+      for i in k...nums.length
+        # Если текущий элемент больше элемента на вершине кучи, извлечь вершину кучи и добавить текущий элемент в кучу
+        if nums[i] > peek_min_heap(max_heap)
+          pop_min_heap(max_heap)
+          push_min_heap(max_heap, nums[i])
+        end
+      end
+
+      get_min_heap(max_heap)
+    end
+    ```
+
+??? pythontutor "Визуализация кода"
+
+    <div style="height: 549px; width: 100%;"><iframe class="pythontutor-iframe" src="https://pythontutor.com/iframe-embed.html#code=import%20heapq%0A%0Adef%20top_k_heap%28nums%3A%20list%5Bint%5D%2C%20k%3A%20int%29%20-%3E%20list%5Bint%5D%3A%0A%20%20%20%20%22%22%22%D0%9D%D0%B0%D0%B9%D1%82%D0%B8%20k%20%D0%BD%D0%B0%D0%B8%D0%B1%D0%BE%D0%BB%D1%8C%D1%88%D0%B8%D1%85%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D0%BE%D0%B2%20%D0%BC%D0%B0%D1%81%D1%81%D0%B8%D0%B2%D0%B0%20%D1%81%20%D0%BF%D0%BE%D0%BC%D0%BE%D1%89%D1%8C%D1%8E%20%D0%BA%D1%83%D1%87%D0%B8%22%22%22%0A%20%20%20%20%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F%20%D0%BC%D0%B8%D0%BD%D0%B8%D0%BC%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B9%20%D0%BA%D1%83%D1%87%D0%B8%0A%20%20%20%20heap%20%3D%20%5B%5D%0A%20%20%20%20%23%20%D0%9F%D0%BE%D0%BC%D0%B5%D1%81%D1%82%D0%B8%D1%82%D1%8C%20%D0%BF%D0%B5%D1%80%D0%B2%D1%8B%D0%B5%20k%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D0%BE%D0%B2%20%D0%BC%D0%B0%D1%81%D1%81%D0%B8%D0%B2%D0%B0%20%D0%B2%20%D0%BA%D1%83%D1%87%D1%83%0A%20%20%20%20for%20i%20in%20range%28k%29%3A%0A%20%20%20%20%20%20%20%20heapq.heappush%28heap%2C%20nums%5Bi%5D%29%0A%20%20%20%20%23%20%D0%9D%D0%B0%D1%87%D0%B8%D0%BD%D0%B0%D1%8F%20%D1%81%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D0%B0%20k%2B1%2C%20%D0%BF%D0%BE%D0%B4%D0%B4%D0%B5%D1%80%D0%B6%D0%B8%D0%B2%D0%B0%D1%82%D1%8C%20%D0%B4%D0%BB%D0%B8%D0%BD%D1%83%20%D0%BA%D1%83%D1%87%D0%B8%20%D1%80%D0%B0%D0%B2%D0%BD%D0%BE%D0%B9%20k%0A%20%20%20%20for%20i%20in%20range%28k%2C%20len%28nums%29%29%3A%0A%20%20%20%20%20%20%20%20%23%20%D0%95%D1%81%D0%BB%D0%B8%20%D1%82%D0%B5%D0%BA%D1%83%D1%89%D0%B8%D0%B9%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%B1%D0%BE%D0%BB%D1%8C%D1%88%D0%B5%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D0%B0%20%D0%BD%D0%B0%20%D0%B2%D0%B5%D1%80%D1%88%D0%B8%D0%BD%D0%B5%20%D0%BA%D1%83%D1%87%D0%B8%2C%20%D0%B8%D0%B7%D0%B2%D0%BB%D0%B5%D1%87%D1%8C%20%D0%B2%D0%B5%D1%80%D1%88%D0%B8%D0%BD%D1%83%20%D0%BA%D1%83%D1%87%D0%B8%20%D0%B8%20%D0%B4%D0%BE%D0%B1%D0%B0%D0%B2%D0%B8%D1%82%D1%8C%20%D1%82%D0%B5%D0%BA%D1%83%D1%89%D0%B8%D0%B9%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%B2%20%D0%BA%D1%83%D1%87%D1%83%0A%20%20%20%20%20%20%20%20if%20nums%5Bi%5D%20%3E%20heap%5B0%5D%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20heapq.heappop%28heap%29%0A%20%20%20%20%20%20%20%20%20%20%20%20heapq.heappush%28heap%2C%20nums%5Bi%5D%29%0A%20%20%20%20return%20heap%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20nums%20%3D%20%5B1%2C%207%2C%206%2C%203%2C%202%5D%0A%20%20%20%20k%20%3D%203%0A%0A%20%20%20%20res%20%3D%20top_k_heap%28nums%2C%20k%29&codeDivHeight=472&codeDivWidth=350&cumulative=false&curInstr=6&heapPrimitives=nevernest&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false"> </iframe></div>
+    <div style="margin-top: 5px;"><a href="https://pythontutor.com/iframe-embed.html#code=import%20heapq%0A%0Adef%20top_k_heap%28nums%3A%20list%5Bint%5D%2C%20k%3A%20int%29%20-%3E%20list%5Bint%5D%3A%0A%20%20%20%20%22%22%22%D0%9D%D0%B0%D0%B9%D1%82%D0%B8%20k%20%D0%BD%D0%B0%D0%B8%D0%B1%D0%BE%D0%BB%D1%8C%D1%88%D0%B8%D1%85%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D0%BE%D0%B2%20%D0%BC%D0%B0%D1%81%D1%81%D0%B8%D0%B2%D0%B0%20%D1%81%20%D0%BF%D0%BE%D0%BC%D0%BE%D1%89%D1%8C%D1%8E%20%D0%BA%D1%83%D1%87%D0%B8%22%22%22%0A%20%20%20%20%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F%20%D0%BC%D0%B8%D0%BD%D0%B8%D0%BC%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B9%20%D0%BA%D1%83%D1%87%D0%B8%0A%20%20%20%20heap%20%3D%20%5B%5D%0A%20%20%20%20%23%20%D0%9F%D0%BE%D0%BC%D0%B5%D1%81%D1%82%D0%B8%D1%82%D1%8C%20%D0%BF%D0%B5%D1%80%D0%B2%D1%8B%D0%B5%20k%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D0%BE%D0%B2%20%D0%BC%D0%B0%D1%81%D1%81%D0%B8%D0%B2%D0%B0%20%D0%B2%20%D0%BA%D1%83%D1%87%D1%83%0A%20%20%20%20for%20i%20in%20range%28k%29%3A%0A%20%20%20%20%20%20%20%20heapq.heappush%28heap%2C%20nums%5Bi%5D%29%0A%20%20%20%20%23%20%D0%9D%D0%B0%D1%87%D0%B8%D0%BD%D0%B0%D1%8F%20%D1%81%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D0%B0%20k%2B1%2C%20%D0%BF%D0%BE%D0%B4%D0%B4%D0%B5%D1%80%D0%B6%D0%B8%D0%B2%D0%B0%D1%82%D1%8C%20%D0%B4%D0%BB%D0%B8%D0%BD%D1%83%20%D0%BA%D1%83%D1%87%D0%B8%20%D1%80%D0%B0%D0%B2%D0%BD%D0%BE%D0%B9%20k%0A%20%20%20%20for%20i%20in%20range%28k%2C%20len%28nums%29%29%3A%0A%20%20%20%20%20%20%20%20%23%20%D0%95%D1%81%D0%BB%D0%B8%20%D1%82%D0%B5%D0%BA%D1%83%D1%89%D0%B8%D0%B9%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%B1%D0%BE%D0%BB%D1%8C%D1%88%D0%B5%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D0%B0%20%D0%BD%D0%B0%20%D0%B2%D0%B5%D1%80%D1%88%D0%B8%D0%BD%D0%B5%20%D0%BA%D1%83%D1%87%D0%B8%2C%20%D0%B8%D0%B7%D0%B2%D0%BB%D0%B5%D1%87%D1%8C%20%D0%B2%D0%B5%D1%80%D1%88%D0%B8%D0%BD%D1%83%20%D0%BA%D1%83%D1%87%D0%B8%20%D0%B8%20%D0%B4%D0%BE%D0%B1%D0%B0%D0%B2%D0%B8%D1%82%D1%8C%20%D1%82%D0%B5%D0%BA%D1%83%D1%89%D0%B8%D0%B9%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%B2%20%D0%BA%D1%83%D1%87%D1%83%0A%20%20%20%20%20%20%20%20if%20nums%5Bi%5D%20%3E%20heap%5B0%5D%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20heapq.heappop%28heap%29%0A%20%20%20%20%20%20%20%20%20%20%20%20heapq.heappush%28heap%2C%20nums%5Bi%5D%29%0A%20%20%20%20return%20heap%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20nums%20%3D%20%5B1%2C%207%2C%206%2C%203%2C%202%5D%0A%20%20%20%20k%20%3D%203%0A%0A%20%20%20%20res%20%3D%20top_k_heap%28nums%2C%20k%29&codeDivHeight=800&codeDivWidth=600&cumulative=false&curInstr=6&heapPrimitives=nevernest&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false" target="_blank" rel="noopener noreferrer">Во весь экран ></a></div>
+
+Всего выполняется $n$ операций добавления и извлечения из кучи, а максимальная длина кучи равна $k$ , поэтому временная сложность равна $O(n \log k)$ . Этот метод очень эффективен: когда $k$ мало, временная сложность стремится к $O(n)$ ; когда $k$ велико, она все равно не превышает $O(n \log n)$ .
+
+Кроме того, этот метод подходит и для сценариев с динамическим потоком данных. При непрерывном поступлении новых данных мы можем продолжать поддерживать содержимое кучи, тем самым динамически обновляя наибольшие $k$ элементов.