Re-translate the Japanese version (#1871)

* Retranslate Japanese docs with GPT-5.4

* Retranslate Japanese code with GPT-5.4

ja/codes/swift/chapter_heap/heap.swift

@@ -0,0 +1,62 @@
+/**
+ * File: heap.swift
+ * Created Time: 2024-03-17
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+import HeapModule
+import utils
+
+func testPush(heap: inout Heap<Int>, val: Int) {
+    heap.insert(val)
+    print("\n要素 \(val) をヒープに追加した後\n")
+    PrintUtil.printHeap(queue: heap.unordered)
+}
+
+func testPop(heap: inout Heap<Int>) {
+    let val = heap.removeMax()
+    print("\nヒープ先頭要素 \(val) を取り出した後\n")
+    PrintUtil.printHeap(queue: heap.unordered)
+}
+
+@main
+enum _Heap {
+    /* Driver Code */
+    static func main() {
+        /* ヒープを初期化 */
+        // Swift の Heap 型は最大ヒープと最小ヒープの両方をサポートする
+        var heap = Heap<Int>()
+
+        /* 要素をヒープに追加 */
+        testPush(heap: &heap, val: 1)
+        testPush(heap: &heap, val: 3)
+        testPush(heap: &heap, val: 2)
+        testPush(heap: &heap, val: 5)
+        testPush(heap: &heap, val: 4)
+
+        /* ヒープ頂点の要素を取得 */
+        let peek = heap.max()
+        print("\nヒープ先頭要素は \(peek!)\n")
+
+        /* ヒープ頂点の要素を取り出す */
+        testPop(heap: &heap)
+        testPop(heap: &heap)
+        testPop(heap: &heap)
+        testPop(heap: &heap)
+        testPop(heap: &heap)
+
+        /* ヒープのサイズを取得 */
+        let size = heap.count
+        print("\nヒープ内の要素数は \(size)\n")
+
+        /* ヒープが空かどうかを判定 */
+        let isEmpty = heap.isEmpty
+        print("\nヒープが空かどうか \(isEmpty)\n")
+
+        /* リストを入力してヒープを構築 */
+        // 時間計算量は O(n) であり、O(nlogn) ではない
+        let heap2 = Heap([1, 3, 2, 5, 4])
+        print("\nリストを入力してヒープを構築した後")
+        PrintUtil.printHeap(queue: heap2.unordered)
+    }
+}

ja/codes/swift/chapter_heap/my_heap.swift

@@ -0,0 +1,163 @@
+/**
+ * File: my_heap.swift
+ * Created Time: 2023-01-28
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+import utils
+
+/* 最大ヒープ */
+class MaxHeap {
+    private var maxHeap: [Int]
+
+    /* コンストラクタ。入力リストに基づいてヒープを構築する */
+    init(nums: [Int]) {
+        // リスト要素をそのままヒープに追加
+        maxHeap = nums
+        // 葉ノード以外のすべてのノードをヒープ化
+        for i in (0 ... parent(i: size() - 1)).reversed() {
+            siftDown(i: i)
+        }
+    }
+
+    /* 左子ノードのインデックスを取得 */
+    private func left(i: Int) -> Int {
+        2 * i + 1
+    }
+
+    /* 右子ノードのインデックスを取得 */
+    private func right(i: Int) -> Int {
+        2 * i + 2
+    }
+
+    /* 親ノードのインデックスを取得 */
+    private func parent(i: Int) -> Int {
+        (i - 1) / 2 // 切り捨て除算
+    }
+
+    /* 要素を交換 */
+    private func swap(i: Int, j: Int) {
+        maxHeap.swapAt(i, j)
+    }
+
+    /* ヒープのサイズを取得 */
+    func size() -> Int {
+        maxHeap.count
+    }
+
+    /* ヒープが空かどうかを判定 */
+    func isEmpty() -> Bool {
+        size() == 0
+    }
+
+    /* ヒープ先頭要素にアクセス */
+    func peek() -> Int {
+        maxHeap[0]
+    }
+
+    /* 要素をヒープに追加 */
+    func push(val: Int) {
+        // ノードを追加
+        maxHeap.append(val)
+        // 下から上へヒープ化
+        siftUp(i: size() - 1)
+    }
+
+    /* ノード i から始めて、下から上へヒープ化 */
+    private func siftUp(i: Int) {
+        var i = i
+        while true {
+            // ノード i の親ノードを取得
+            let p = parent(i: i)
+            // 「根ノードを越えた」または「ノードの修復が不要」になったらヒープ化を終了
+            if p < 0 || maxHeap[i] <= maxHeap[p] {
+                break
+            }
+            // 2 つのノードを交換
+            swap(i: i, j: p)
+            // ループで下から上へヒープ化
+            i = p
+        }
+    }
+
+    /* 要素をヒープから取り出す */
+    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 から始めて、上から下へヒープ化 */
+    private 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
+            }
+            // 2 つのノードを交換
+            swap(i: i, j: ma)
+            // ループで上から下へヒープ化
+            i = ma
+        }
+    }
+
+    /* ヒープ（二分木）を出力 */
+    func print() {
+        let queue = maxHeap
+        PrintUtil.printHeap(queue: queue)
+    }
+}
+
+@main
+enum MyHeap {
+    /* Driver Code */
+    static func main() {
+        /* 最大ヒープを初期化 */
+        let maxHeap = MaxHeap(nums: [9, 8, 6, 6, 7, 5, 2, 1, 4, 3, 6, 2])
+        print("\nリストを入力してヒープを構築した後")
+        maxHeap.print()
+
+        /* ヒープ頂点の要素を取得 */
+        var peek = maxHeap.peek()
+        print("\nヒープ先頭要素は \(peek)")
+
+        /* 要素をヒープに追加 */
+        let val = 7
+        maxHeap.push(val: val)
+        print("\n要素 \(val) をヒープに追加した後")
+        maxHeap.print()
+
+        /* ヒープ頂点の要素を取り出す */
+        peek = maxHeap.pop()
+        print("\nヒープ先頭要素 \(peek) を取り出した後")
+        maxHeap.print()
+
+        /* ヒープのサイズを取得 */
+        let size = maxHeap.size()
+        print("\nヒープ内の要素数は \(size)")
+
+        /* ヒープが空かどうかを判定 */
+        let isEmpty = maxHeap.isEmpty()
+        print("\nヒープが空かどうか \(isEmpty)")
+    }
+}

ja/codes/swift/chapter_heap/top_k.swift

@@ -0,0 +1,36 @@
+/**
+ * File: top_k.swift
+ * Created Time: 2023-07-02
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+import HeapModule
+import utils
+
+/* ヒープに基づいて配列中の最大の 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
+}
+
+@main
+enum TopK {
+    /* Driver Code */
+    static func main() {
+        let nums = [1, 7, 6, 3, 2]
+        let k = 3
+
+        let res = topKHeap(nums: nums, k: k)
+        print("最大の \(k) 個の要素は")
+        PrintUtil.printHeap(queue: res)
+    }
+}