Re-translate the Japanese version (#1871)

* Retranslate Japanese docs with GPT-5.4 * Retranslate Japanese code with GPT-5.4
2026-08-12 03:40:58 +00:00 · 2026-03-30 07:30:15 +08:00
parent fe6443235b
commit d7b2277d2b
1444 changed files with 83312 additions and 8363 deletions
@@ -0,0 +1,71 @@
+/*
+ * File: heap.rs
+ * Created Time: 2023-07-16
+ * Author: night-cruise (2586447362@qq.com)
+ */
+
+use hello_algo_rust::include::print_util;
+
+use std::{cmp::Reverse, collections::BinaryHeap};
+
+fn test_push_max(heap: &mut BinaryHeap<i32>, val: i32) {
+    heap.push(val); // 要素をヒープに追加
+    println!("\n要素 {} をヒープに追加した後", val);
+    print_util::print_heap(heap.iter().map(|&val| val).collect());
+}
+
+fn test_pop_max(heap: &mut BinaryHeap<i32>) {
+    let val = heap.pop().unwrap();
+    println!("\nヒープ先頭要素 {} を取り出した後", val);
+    print_util::print_heap(heap.iter().map(|&val| val).collect());
+}
+
+/* Driver Code */
+fn main() {
+    /* ヒープを初期化 */
+    // 最小ヒープを初期化
+    #[allow(unused_assignments)]
+    let mut min_heap = BinaryHeap::new();
+    // Rust の BinaryHeap は最大ヒープであり、最小ヒープには通常 Reverse を使う
+    // 最大ヒープを初期化する
+    let mut max_heap = BinaryHeap::new();
+
+    println!("\n以下のテストケースは最大ヒープです");
+
+    /* 要素をヒープに追加 */
+    test_push_max(&mut max_heap, 1);
+    test_push_max(&mut max_heap, 3);
+    test_push_max(&mut max_heap, 2);
+    test_push_max(&mut max_heap, 5);
+    test_push_max(&mut max_heap, 4);
+
+    /* ヒープ頂点の要素を取得 */
+    let peek = max_heap.peek().unwrap();
+    println!("\nヒープ先頭要素は {}", peek);
+
+    /* ヒープ頂点の要素を取り出す */
+    test_pop_max(&mut max_heap);
+    test_pop_max(&mut max_heap);
+    test_pop_max(&mut max_heap);
+    test_pop_max(&mut max_heap);
+    test_pop_max(&mut max_heap);
+
+    /* ヒープのサイズを取得 */
+    let size = max_heap.len();
+    println!("\nヒープ要素数は {}", size);
+
+    /* ヒープが空かどうかを判定 */
+    let is_empty = max_heap.is_empty();
+    println!("\nヒープは空か {}", is_empty);
+
+    /* リストを入力してヒープを構築 */
+    // 時間計算量は O(n) であり、O(nlogn) ではない
+    min_heap = BinaryHeap::from(
+        vec![1, 3, 2, 5, 4]
+            .into_iter()
+            .map(|val| Reverse(val))
+            .collect::<Vec<Reverse<i32>>>(),
+    );
+    println!("\nリストを入力して最小ヒープを構築した後");
+    print_util::print_heap(min_heap.iter().map(|&val| val.0).collect());
+}
@@ -0,0 +1,165 @@
+/*
+ * File: my_heap.rs
+ * Created Time: 2023-07-16
+ * Author: night-cruise (2586447362@qq.com)
+ */
+
+use hello_algo_rust::include::print_util;
+
+/* 最大ヒープ */
+struct MaxHeap {
+    // 配列ではなく vector を使うことで、拡張を考慮せずに済む
+    max_heap: Vec<i32>,
+}
+
+impl MaxHeap {
+    /* コンストラクタ。入力リストに基づいてヒープを構築する */
+    fn new(nums: Vec<i32>) -> Self {
+        // リスト要素をそのままヒープに追加
+        let mut heap = MaxHeap { max_heap: nums };
+        // 葉ノード以外のすべてのノードをヒープ化
+        for i in (0..=Self::parent(heap.size() - 1)).rev() {
+            heap.sift_down(i);
+        }
+        heap
+    }
+
+    /* 左子ノードのインデックスを取得 */
+    fn left(i: usize) -> usize {
+        2 * i + 1
+    }
+
+    /* 右子ノードのインデックスを取得 */
+    fn right(i: usize) -> usize {
+        2 * i + 2
+    }
+
+    /* 親ノードのインデックスを取得 */
+    fn parent(i: usize) -> usize {
+        (i - 1) / 2 // 切り捨て除算
+    }
+
+    /* 要素を交換 */
+    fn swap(&mut self, i: usize, j: usize) {
+        self.max_heap.swap(i, j);
+    }
+
+    /* ヒープのサイズを取得 */
+    fn size(&self) -> usize {
+        self.max_heap.len()
+    }
+
+    /* ヒープが空かどうかを判定 */
+    fn is_empty(&self) -> bool {
+        self.max_heap.is_empty()
+    }
+
+    /* ヒープ先頭要素にアクセス */
+    fn peek(&self) -> Option<i32> {
+        self.max_heap.first().copied()
+    }
+
+    /* 要素をヒープに追加 */
+    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;
+            }
+            // 2 つのノードを交換
+            self.swap(i, p);
+            // ループで下から上へヒープ化
+            i = p;
+        }
+    }
+
+    /* 要素をヒープから取り出す */
+    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;
+            }
+            // 2 つのノードを交換
+            self.swap(i, ma);
+            // ループで上から下へヒープ化
+            i = ma;
+        }
+    }
+
+    /* ヒープ（二分木）を出力 */
+    fn print(&self) {
+        print_util::print_heap(self.max_heap.clone());
+    }
+}
+
+/* Driver Code */
+fn main() {
+    /* 最大ヒープを初期化 */
+    let mut max_heap = MaxHeap::new(vec![9, 8, 6, 6, 7, 5, 2, 1, 4, 3, 6, 2]);
+    println!("\nリストを入力してヒープを構築した後");
+    max_heap.print();
+
+    /* ヒープ頂点の要素を取得 */
+    let peek = max_heap.peek();
+    if let Some(peek) = peek {
+        println!("\nヒープ先頭要素は {}", peek);
+    }
+
+    /* 要素をヒープに追加 */
+    let val = 7;
+    max_heap.push(val);
+    println!("\n要素 {} をヒープに追加した後", val);
+    max_heap.print();
+
+    /* ヒープ頂点の要素を取り出す */
+    let peek = max_heap.pop();
+    println!("\nヒープ先頭要素 {} を取り出した後", peek);
+    max_heap.print();
+
+    /* ヒープのサイズを取得 */
+    let size = max_heap.size();
+    println!("\nヒープ要素数は {}", size);
+
+    /* ヒープが空かどうかを判定 */
+    let is_empty = max_heap.is_empty();
+    println!("\nヒープは空か {}", is_empty);
+}
@@ -0,0 +1,39 @@
+/*
+ * File: top_k.rs
+ * Created Time: 2023-07-16
+ * Author: night-cruise (2586447362@qq.com)
+ */
+
+use hello_algo_rust::include::print_util;
+
+use std::cmp::Reverse;
+use std::collections::BinaryHeap;
+
+/* ヒープに基づいて配列中の最大の 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
+}
+
+/* Driver Code */
+fn main() {
+    let nums = vec![1, 7, 6, 3, 2];
+    let k = 3;
+
+    let res = top_k_heap(nums, k);
+    println!("最大の {} 個の要素は", k);
+    print_util::print_heap(res.into_iter().map(|item| item.0).collect());
+}