build

docs/chapter_heap/build_heap.md

@@ -185,6 +185,126 @@ comments: true
     }
     ```
 
+=== "Kotlin"
+
+    ```kotlin title="my_heap.kt"
+    /* 大顶堆 */
+    class MaxHeap(nums: List<Int>?) {
+        // 使用列表而非数组，这样无须考虑扩容问题
+        // 将列表元素原封不动添加进堆
+        private val maxHeap = ArrayList(nums!!)
+
+        /* 构造函数，根据输入列表建堆 */
+        init {
+            // 堆化除叶节点以外的其他所有节点
+            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) {
+            maxHeap[i] = maxHeap[j].also { maxHeap[j] = maxHeap[i] }
+        }
+
+        /* 获取堆大小 */
+        fun size(): Int {
+            return maxHeap.size
+        }
+
+        /* 判断堆是否为空 */
+        fun isEmpty(): Boolean {
+            /* 判断堆是否为空 */
+            return size() == 0
+        }
+
+        /* 访问堆顶元素 */
+        fun peek(): Int {
+            return maxHeap[0]
+        }
+
+        /* 元素入堆 */
+        fun push(value: Int) {
+            // 添加节点
+            maxHeap.add(value)
+            // 从底至顶堆化
+            siftUp(size() - 1)
+        }
+
+        /* 从节点 i 开始，从底至顶堆化 */
+        private fun siftUp(it: Int) {
+            // Kotlin的函数参数不可变，因此创建临时变量
+            var i = it
+            while (true) {
+                // 获取节点 i 的父节点
+                val p = parent(i)
+                // 当“越过根节点”或“节点无须修复”时，结束堆化
+                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 value = maxHeap.removeAt(size() - 1)
+            // 从顶至底堆化
+            siftDown(0)
+            // 返回堆顶元素
+            return value
+        }
+
+        /* 从节点 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)
+        }
+    }
+    ```
+
 === "Zig"
 
     ```zig title="my_heap.zig"

docs/chapter_heap/heap.md

@@ -375,6 +375,12 @@ comments: true
     // C 未提供内置 Heap 类
     ```
 
+=== "Kotlin"
+
+    ```kotlin title="heap.kt"
+
+    ```
+
 === "Zig"
 
     ```zig title="heap.zig"
@@ -611,6 +617,25 @@ comments: true
     }
     ```
 
+=== "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 // 向下整除
+    }
+    ```
+
 === "Zig"
 
     ```zig title="my_heap.zig"
@@ -733,6 +758,15 @@ comments: true
     }
     ```
 
+=== "Kotlin"
+
+    ```kotlin title="my_heap.kt"
+    /* 访问堆顶元素 */
+    fun peek(): Int {
+        return maxHeap[0]
+    }
+    ```
+
 === "Zig"
 
     ```zig title="my_heap.zig"
@@ -1093,6 +1127,34 @@ comments: true
     }
     ```
 
+=== "Kotlin"
+
+    ```kotlin title="my_heap.kt"
+    /* 元素入堆 */
+    fun push(value: Int) {
+        // 添加节点
+        maxHeap.add(value)
+        // 从底至顶堆化
+        siftUp(size() - 1)
+    }
+
+    /* 从节点 i 开始，从底至顶堆化 */
+    fun siftUp(it: Int) {
+        // Kotlin的函数参数不可变，因此创建临时变量
+        var i = it
+        while (true) {
+            // 获取节点 i 的父节点
+            val p = parent(i)
+            // 当“越过根节点”或“节点无须修复”时，结束堆化
+            if (p < 0 || maxHeap[i] <= maxHeap[p]) break
+            // 交换两节点
+            swap(i, p)
+            // 循环向上堆化
+            i = p
+        }
+    }
+    ```
+
 === "Zig"
 
     ```zig title="my_heap.zig"
@@ -1603,6 +1665,44 @@ comments: true
     }
     ```
 
+=== "Kotlin"
+
+    ```kotlin title="my_heap.kt"
+    /* 元素出堆 */
+    fun pop(): Int {
+        // 判空处理
+        if (isEmpty()) throw IndexOutOfBoundsException()
+        // 交换根节点与最右叶节点（交换首元素与尾元素）
+        swap(0, size() - 1)
+        // 删除节点
+        val value = maxHeap.removeAt(size() - 1)
+        // 从顶至底堆化
+        siftDown(0)
+        // 返回堆顶元素
+        return value
+    }
+
+    /* 从节点 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
+        }
+    }
+    ```
+
 === "Zig"
 
     ```zig title="my_heap.zig"

docs/chapter_heap/top_k.md

@@ -411,6 +411,29 @@ comments: true
     }
     ```
 
+=== "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
+    }
+    ```
+
 === "Zig"
 
     ```zig title="top_k.zig"