Re-translate the Japanese version (#1871)

* Retranslate Japanese docs with GPT-5.4

* Retranslate Japanese code with GPT-5.4

ja/codes/kotlin/chapter_heap/heap.kt

@@ -0,0 +1,66 @@
+/**
+ * File: heap.kt
+ * Created Time: 2024-01-25
+ * Author: curtishd (1023632660@qq.com)
+ */
+
+package chapter_heap
+
+import utils.printHeap
+import java.util.*
+
+fun testPush(heap: Queue<Int>, _val: Int) {
+    heap.offer(_val) // 要素をヒープに追加
+    print("\n要素 $_val をヒープに追加した後\n")
+    printHeap(heap)
+}
+
+fun testPop(heap: Queue<Int>) {
+    val _val = heap.poll() // ヒープ頂点の要素を取り出す
+    print("\nヒープ先頭要素 $_val を取り出した後\n")
+    printHeap(heap)
+}
+
+/* Driver Code */
+fun main() {
+    /* ヒープを初期化 */
+    // 最小ヒープを初期化
+    var minHeap = PriorityQueue<Int>()
+
+    // 最大ヒープを初期化する（lambda 式で Comparator を変更すればよい）
+    val maxHeap = PriorityQueue { a: Int, b: Int -> b - a }
+
+    println("\n以下のテストケースは最大ヒープです")
+
+    /* 要素をヒープに追加 */
+    testPush(maxHeap, 1)
+    testPush(maxHeap, 3)
+    testPush(maxHeap, 2)
+    testPush(maxHeap, 5)
+    testPush(maxHeap, 4)
+
+    /* ヒープ頂点の要素を取得 */
+    val peek = maxHeap.peek()
+    print("\nヒープ先頭要素は $peek\n")
+
+    /* ヒープ頂点の要素を取り出す */
+    testPop(maxHeap)
+    testPop(maxHeap)
+    testPop(maxHeap)
+    testPop(maxHeap)
+    testPop(maxHeap)
+
+    /* ヒープのサイズを取得 */
+    val size = maxHeap.size
+    print("\nヒープ要素数は $size\n")
+
+    /* ヒープが空かどうかを判定 */
+    val isEmpty = maxHeap.isEmpty()
+    print("\nヒープが空かどうか $isEmpty\n")
+
+    /* リストを入力してヒープを構築 */
+    // 時間計算量は O(n) であり、O(nlogn) ではない
+    minHeap = PriorityQueue(mutableListOf<Int?>(1, 3, 2, 5, 4))
+    println("\n入力リストから最小ヒープを構築した後")
+    printHeap(minHeap)
+}

ja/codes/kotlin/chapter_heap/my_heap.kt

@@ -0,0 +1,160 @@
+/**
+ * File: my_heap.kt
+ * Created Time: 2024-01-25
+ * Author: curtishd (1023632660@qq.com)
+ */
+
+package chapter_heap
+
+import utils.printHeap
+import java.util.*
+
+/* 最大ヒープ */
+class MaxHeap(nums: MutableList<Int>?) {
+    // 配列ではなくリストを使うことで、拡張を考慮する必要がない
+    private val maxHeap = mutableListOf<Int>()
+
+    /* コンストラクタ。入力リストに基づいてヒープを構築する */
+    init {
+        // リスト要素をそのままヒープに追加
+        maxHeap.addAll(nums!!)
+        // 葉ノード以外のすべてのノードをヒープ化
+        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)
+            // 「根ノードを越えた」または「ノードの修復が不要」になったらヒープ化を終了
+            if (p < 0 || maxHeap[i] <= maxHeap[p]) break
+            // 2 つのノードを交換
+            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
+            // 2 つのノードを交換
+            swap(i, ma)
+            // ループで上から下へヒープ化
+            i = ma
+        }
+    }
+
+    /* ヒープ（二分木）を出力 */
+    fun print() {
+        val queue = PriorityQueue { a: Int, b: Int -> b - a }
+        queue.addAll(maxHeap)
+        printHeap(queue)
+    }
+}
+
+/* Driver Code */
+fun main() {
+    /* 最大ヒープを初期化 */
+    val maxHeap = MaxHeap(mutableListOf(9, 8, 6, 6, 7, 5, 2, 1, 4, 3, 6, 2))
+    println("\n入力リストからヒープを構築した後")
+    maxHeap.print()
+
+    /* ヒープ頂点の要素を取得 */
+    var peek = maxHeap.peek()
+    print("\nヒープ先頭要素は $peek\n")
+
+    /* 要素をヒープに追加 */
+    val _val = 7
+    maxHeap.push(_val)
+    print("\n要素 $_val をヒープに追加した後\n")
+    maxHeap.print()
+
+    /* ヒープ頂点の要素を取り出す */
+    peek = maxHeap.pop()
+    print("\nヒープ先頭要素 $peek を取り出した後\n")
+    maxHeap.print()
+
+    /* ヒープのサイズを取得 */
+    val size = maxHeap.size()
+    print("\nヒープ要素数は $size\n")
+
+    /* ヒープが空かどうかを判定 */
+    val isEmpty = maxHeap.isEmpty()
+    print("\nヒープが空かどうか $isEmpty\n")
+}

ja/codes/kotlin/chapter_heap/top_k.kt

@@ -0,0 +1,38 @@
+/**
+ * File: top_k.kt
+ * Created Time: 2024-01-25
+ * Author: curtishd (1023632660@qq.com)
+ */
+
+package chapter_heap
+
+import utils.printHeap
+import java.util.*
+
+/* ヒープに基づいて配列中の最大の 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
+}
+
+/* Driver Code */
+fun main() {
+    val nums = intArrayOf(1, 7, 6, 3, 2)
+    val k = 3
+    val res = topKHeap(nums, k)
+    println("最大の $k 個の要素は")
+    printHeap(res)
+}