Re-translate the Japanese version (#1871)

* Retranslate Japanese docs with GPT-5.4

* Retranslate Japanese code with GPT-5.4

ja/codes/rust/chapter_tree/array_binary_tree.rs

@@ -0,0 +1,192 @@
+/*
+ * File: array_binary_tree.rs
+ * Created Time: 2023-07-25
+ * Author: night-cruise (2586447362@qq.com)
+ */
+
+use hello_algo_rust::include::{print_util, tree_node};
+
+/* 配列表現による二分木クラス */
+struct ArrayBinaryTree {
+    tree: Vec<Option<i32>>,
+}
+
+impl ArrayBinaryTree {
+    /* コンストラクタ */
+    fn new(arr: Vec<Option<i32>>) -> Self {
+        Self { tree: arr }
+    }
+
+    /* リスト容量 */
+    fn size(&self) -> i32 {
+        self.tree.len() as i32
+    }
+
+    /* インデックス i のノードの値を取得 */
+    fn val(&self, i: i32) -> Option<i32> {
+        // インデックスが範囲外なら、空きを表す None を返す
+        if i < 0 || i >= self.size() {
+            None
+        } else {
+            self.tree[i as usize]
+        }
+    }
+
+    /* インデックス i のノードの左子ノードのインデックスを取得 */
+    fn left(&self, i: i32) -> i32 {
+        2 * i + 1
+    }
+
+    /* インデックス i のノードの右子ノードのインデックスを取得 */
+    fn right(&self, i: i32) -> i32 {
+        2 * i + 2
+    }
+
+    /* インデックス i のノードの親ノードのインデックスを取得 */
+    fn parent(&self, i: i32) -> i32 {
+        (i - 1) / 2
+    }
+
+    /* レベル順走査 */
+    fn level_order(&self) -> Vec<i32> {
+        self.tree.iter().filter_map(|&x| x).collect()
+    }
+
+    /* 深さ優先探索 */
+    fn dfs(&self, i: i32, order: &'static str, res: &mut Vec<i32>) {
+        if self.val(i).is_none() {
+            return;
+        }
+        let val = self.val(i).unwrap();
+        // 先行順走査
+        if order == "pre" {
+            res.push(val);
+        }
+        self.dfs(self.left(i), order, res);
+        // 中順走査
+        if order == "in" {
+            res.push(val);
+        }
+        self.dfs(self.right(i), order, res);
+        // 後順走査
+        if order == "post" {
+            res.push(val);
+        }
+    }
+
+    /* 先行順走査 */
+    fn pre_order(&self) -> Vec<i32> {
+        let mut res = vec![];
+        self.dfs(0, "pre", &mut res);
+        res
+    }
+
+    /* 中順走査 */
+    fn in_order(&self) -> Vec<i32> {
+        let mut res = vec![];
+        self.dfs(0, "in", &mut res);
+        res
+    }
+
+    /* 後順走査 */
+    fn post_order(&self) -> Vec<i32> {
+        let mut res = vec![];
+        self.dfs(0, "post", &mut res);
+        res
+    }
+}
+
+/* Driver Code */
+fn main() {
+    // 二分木を初期化
+    // ここでは、配列から直接二分木を生成する関数を利用する
+    let arr = vec![
+        Some(1),
+        Some(2),
+        Some(3),
+        Some(4),
+        None,
+        Some(6),
+        Some(7),
+        Some(8),
+        Some(9),
+        None,
+        None,
+        Some(12),
+        None,
+        None,
+        Some(15),
+    ];
+
+    let root = tree_node::vec_to_tree(arr.clone()).unwrap();
+    println!("\n二分木を初期化\n");
+    println!("二分木の配列表現：");
+    println!(
+        "[{}]",
+        arr.iter()
+            .map(|&val| if let Some(val) = val {
+                format!("{val}")
+            } else {
+                "null".to_string()
+            })
+            .collect::<Vec<String>>()
+            .join(", ")
+    );
+    println!("二分木の連結リスト表現：");
+    print_util::print_tree(&root);
+
+    // 配列表現による二分木クラス
+    let abt = ArrayBinaryTree::new(arr);
+
+    // ノードにアクセス
+    let i = 1;
+    let l = abt.left(i);
+    let r = abt.right(i);
+    let p = abt.parent(i);
+    println!(
+        "\n現在のノードのインデックスは {}、値は {}",
+        i,
+        if let Some(val) = abt.val(i) {
+            format!("{val}")
+        } else {
+            "null".to_string()
+        }
+    );
+    println!(
+        "その左子ノードのインデックスは {}、値は {}",
+        l,
+        if let Some(val) = abt.val(l) {
+            format!("{val}")
+        } else {
+            "null".to_string()
+        }
+    );
+    println!(
+        "その右子ノードのインデックスは {}、値は {}",
+        r,
+        if let Some(val) = abt.val(r) {
+            format!("{val}")
+        } else {
+            "null".to_string()
+        }
+    );
+    println!(
+        "その親ノードのインデックスは {}、値は {}",
+        p,
+        if let Some(val) = abt.val(p) {
+            format!("{val}")
+        } else {
+            "null".to_string()
+        }
+    );
+
+    // 木を走査
+    let mut res = abt.level_order();
+    println!("\nレベル順走査：{:?}", res);
+    res = abt.pre_order();
+    println!("前順走査：{:?}", res);
+    res = abt.in_order();
+    println!("中順走査：{:?}", res);
+    res = abt.post_order();
+    println!("後順走査は：{:?}", res);
+}

ja/codes/rust/chapter_tree/avl_tree.rs

@@ -0,0 +1,297 @@
+/*
+ * File: avl_tree.rs
+ * Created Time: 2023-07-14
+ * Author: night-cruise (2586447362@qq.com)
+ */
+
+use hello_algo_rust::include::{print_util, TreeNode};
+
+use std::cell::RefCell;
+use std::cmp::Ordering;
+use std::rc::Rc;
+
+type OptionTreeNodeRc = Option<Rc<RefCell<TreeNode>>>;
+
+/* AVL 木 */
+struct AVLTree {
+    root: OptionTreeNodeRc, // 根ノード
+}
+
+impl AVLTree {
+    /* コンストラクタ */
+    fn new() -> Self {
+        Self { root: None }
+    }
+
+    /* ノードの高さを取得 */
+    fn height(node: OptionTreeNodeRc) -> i32 {
+        // 空ノードの高さは -1、葉ノードの高さは 0
+        match node {
+            Some(node) => node.borrow().height,
+            None => -1,
+        }
+    }
+
+    /* ノードの高さを更新する */
+    fn update_height(node: OptionTreeNodeRc) {
+        if let Some(node) = node {
+            let left = node.borrow().left.clone();
+            let right = node.borrow().right.clone();
+            // ノードの高さは最も高い部分木の高さ + 1 に等しい
+            node.borrow_mut().height = std::cmp::max(Self::height(left), Self::height(right)) + 1;
+        }
+    }
+
+    /* 平衡係数を取得 */
+    fn balance_factor(node: OptionTreeNodeRc) -> i32 {
+        match node {
+            // 空ノードの平衡係数は 0
+            None => 0,
+            // ノードの平衡係数 = 左部分木の高さ - 右部分木の高さ
+            Some(node) => {
+                Self::height(node.borrow().left.clone()) - Self::height(node.borrow().right.clone())
+            }
+        }
+    }
+
+    /* 右回転 */
+    fn right_rotate(node: OptionTreeNodeRc) -> OptionTreeNodeRc {
+        match node {
+            Some(node) => {
+                let child = node.borrow().left.clone().unwrap();
+                let grand_child = child.borrow().right.clone();
+                // child を支点として node を右回転させる
+                child.borrow_mut().right = Some(node.clone());
+                node.borrow_mut().left = grand_child;
+                // ノードの高さを更新する
+                Self::update_height(Some(node));
+                Self::update_height(Some(child.clone()));
+                // 回転後の部分木の根ノードを返す
+                Some(child)
+            }
+            None => None,
+        }
+    }
+
+    /* 左回転 */
+    fn left_rotate(node: OptionTreeNodeRc) -> OptionTreeNodeRc {
+        match node {
+            Some(node) => {
+                let child = node.borrow().right.clone().unwrap();
+                let grand_child = child.borrow().left.clone();
+                // child を支点として node を左回転させる
+                child.borrow_mut().left = Some(node.clone());
+                node.borrow_mut().right = grand_child;
+                // ノードの高さを更新する
+                Self::update_height(Some(node));
+                Self::update_height(Some(child.clone()));
+                // 回転後の部分木の根ノードを返す
+                Some(child)
+            }
+            None => None,
+        }
+    }
+
+    /* 回転操作を行い、この部分木の平衡を回復する */
+    fn rotate(node: OptionTreeNodeRc) -> OptionTreeNodeRc {
+        // ノード node の平衡係数を取得
+        let balance_factor = Self::balance_factor(node.clone());
+        // 左に偏った木
+        if balance_factor > 1 {
+            let node = node.unwrap();
+            if Self::balance_factor(node.borrow().left.clone()) >= 0 {
+                // 右回転
+                Self::right_rotate(Some(node))
+            } else {
+                // 左回転してから右回転
+                let left = node.borrow().left.clone();
+                node.borrow_mut().left = Self::left_rotate(left);
+                Self::right_rotate(Some(node))
+            }
+        }
+        // 右に偏った木
+        else if balance_factor < -1 {
+            let node = node.unwrap();
+            if Self::balance_factor(node.borrow().right.clone()) <= 0 {
+                // 左回転
+                Self::left_rotate(Some(node))
+            } else {
+                // 右回転してから左回転
+                let right = node.borrow().right.clone();
+                node.borrow_mut().right = Self::right_rotate(right);
+                Self::left_rotate(Some(node))
+            }
+        } else {
+            // 平衡木なので回転不要、そのまま返す
+            node
+        }
+    }
+
+    /* ノードを挿入 */
+    fn insert(&mut self, val: i32) {
+        self.root = Self::insert_helper(self.root.clone(), val);
+    }
+
+    /* ノードを再帰的に挿入する（補助メソッド） */
+    fn insert_helper(node: OptionTreeNodeRc, val: i32) -> OptionTreeNodeRc {
+        match node {
+            Some(mut node) => {
+                /* 1. 挿入位置を探索してノードを挿入 */
+                match {
+                    let node_val = node.borrow().val;
+                    node_val
+                }
+                .cmp(&val)
+                {
+                    Ordering::Greater => {
+                        let left = node.borrow().left.clone();
+                        node.borrow_mut().left = Self::insert_helper(left, val);
+                    }
+                    Ordering::Less => {
+                        let right = node.borrow().right.clone();
+                        node.borrow_mut().right = Self::insert_helper(right, val);
+                    }
+                    Ordering::Equal => {
+                        return Some(node); // 重複ノードは挿入せず、そのまま返す
+                    }
+                }
+                Self::update_height(Some(node.clone())); // ノードの高さを更新する
+
+                /* 2. 回転操作を行い、部分木の平衡を回復する */
+                node = Self::rotate(Some(node)).unwrap();
+                // 部分木の根ノードを返す
+                Some(node)
+            }
+            None => Some(TreeNode::new(val)),
+        }
+    }
+
+    /* ノードを削除 */
+    fn remove(&self, val: i32) {
+        Self::remove_helper(self.root.clone(), val);
+    }
+
+    /* ノードを再帰的に削除する（補助メソッド） */
+    fn remove_helper(node: OptionTreeNodeRc, val: i32) -> OptionTreeNodeRc {
+        match node {
+            Some(mut node) => {
+                /* 1. ノードを探索して削除 */
+                if val < node.borrow().val {
+                    let left = node.borrow().left.clone();
+                    node.borrow_mut().left = Self::remove_helper(left, val);
+                } else if val > node.borrow().val {
+                    let right = node.borrow().right.clone();
+                    node.borrow_mut().right = Self::remove_helper(right, val);
+                } else if node.borrow().left.is_none() || node.borrow().right.is_none() {
+                    let child = if node.borrow().left.is_some() {
+                        node.borrow().left.clone()
+                    } else {
+                        node.borrow().right.clone()
+                    };
+                    match child {
+                        // 子ノード数 = 0 の場合、node をそのまま削除して返す
+                        None => {
+                            return None;
+                        }
+                        // 子ノード数 = 1 の場合、node をそのまま削除する
+                        Some(child) => node = child,
+                    }
+                } else {
+                    // 子ノード数 = 2 の場合、中順走査の次のノードを削除し、そのノードで現在のノードを置き換える
+                    let mut temp = node.borrow().right.clone().unwrap();
+                    loop {
+                        let temp_left = temp.borrow().left.clone();
+                        if temp_left.is_none() {
+                            break;
+                        }
+                        temp = temp_left.unwrap();
+                    }
+                    let right = node.borrow().right.clone();
+                    node.borrow_mut().right = Self::remove_helper(right, temp.borrow().val);
+                    node.borrow_mut().val = temp.borrow().val;
+                }
+                Self::update_height(Some(node.clone())); // ノードの高さを更新する
+
+                /* 2. 回転操作を行い、部分木の平衡を回復する */
+                node = Self::rotate(Some(node)).unwrap();
+                // 部分木の根ノードを返す
+                Some(node)
+            }
+            None => None,
+        }
+    }
+
+    /* ノードを探索 */
+    fn search(&self, val: i32) -> OptionTreeNodeRc {
+        let mut cur = self.root.clone();
+        // ループで探索し、葉ノードを越えたら抜ける
+        while let Some(current) = cur.clone() {
+            match current.borrow().val.cmp(&val) {
+                // 目標ノードは cur の右部分木にある
+                Ordering::Less => {
+                    cur = current.borrow().right.clone();
+                }
+                // 目標ノードは cur の左部分木にある
+                Ordering::Greater => {
+                    cur = current.borrow().left.clone();
+                }
+                // 目標ノードが見つかったらループを抜ける
+                Ordering::Equal => {
+                    break;
+                }
+            }
+        }
+        // 目標ノードを返す
+        cur
+    }
+}
+
+/* Driver Code */
+fn main() {
+    fn test_insert(tree: &mut AVLTree, val: i32) {
+        tree.insert(val);
+        println!("\nノード {} を挿入した後、AVL 木は", val);
+        print_util::print_tree(&tree.root.clone().unwrap());
+    }
+
+    fn test_remove(tree: &mut AVLTree, val: i32) {
+        tree.remove(val);
+        println!("\nノード {} を削除した後、AVL 木は", val);
+        print_util::print_tree(&tree.root.clone().unwrap());
+    }
+
+    /* 空の AVL 木を初期化する */
+    let mut avl_tree = AVLTree::new();
+
+    /* ノードを挿入 */
+    // ノード挿入後に AVL 木がどのように平衡を保つかに注目してほしい
+    test_insert(&mut avl_tree, 1);
+    test_insert(&mut avl_tree, 2);
+    test_insert(&mut avl_tree, 3);
+    test_insert(&mut avl_tree, 4);
+    test_insert(&mut avl_tree, 5);
+    test_insert(&mut avl_tree, 8);
+    test_insert(&mut avl_tree, 7);
+    test_insert(&mut avl_tree, 9);
+    test_insert(&mut avl_tree, 10);
+    test_insert(&mut avl_tree, 6);
+
+    /* 重複ノードを挿入する */
+    test_insert(&mut avl_tree, 7);
+
+    /* ノードを削除 */
+    // ノード削除後に AVL 木がどのように平衡を保つかに注目してほしい
+    test_remove(&mut avl_tree, 8); // 次数 0 のノードを削除する
+    test_remove(&mut avl_tree, 5); // 次数 1 のノードを削除する
+    test_remove(&mut avl_tree, 4); // 次数 2 のノードを削除する
+
+    /* ノードを検索 */
+    let node = avl_tree.search(7);
+    if let Some(node) = node {
+        println!(
+            "\n見つかったノードオブジェクトは {:?}、ノードの値 = {}",
+            &*node.borrow(),
+            node.borrow().val
+        );
+    }
+}

ja/codes/rust/chapter_tree/binary_search_tree.rs

@@ -0,0 +1,195 @@
+/*
+ * File: binary_search_tree.rs
+ * Created Time: 2023-04-20
+ * Author: xBLACKICEx (xBLACKICE@outlook.com)、night-cruise (2586447362@qq.com)
+ */
+
+use hello_algo_rust::include::print_util;
+
+use std::cell::RefCell;
+use std::cmp::Ordering;
+use std::rc::Rc;
+
+use hello_algo_rust::include::TreeNode;
+
+type OptionTreeNodeRc = Option<Rc<RefCell<TreeNode>>>;
+
+/* 二分探索木 */
+pub struct BinarySearchTree {
+    root: OptionTreeNodeRc,
+}
+
+impl BinarySearchTree {
+    /* コンストラクタ */
+    pub fn new() -> Self {
+        // 空の木を初期化する
+        Self { root: None }
+    }
+
+    /* 二分木の根ノードを取得 */
+    pub fn get_root(&self) -> OptionTreeNodeRc {
+        self.root.clone()
+    }
+
+    /* ノードを探索 */
+    pub fn search(&self, num: i32) -> OptionTreeNodeRc {
+        let mut cur = self.root.clone();
+        // ループで探索し、葉ノードを越えたら抜ける
+        while let Some(node) = cur.clone() {
+            match num.cmp(&node.borrow().val) {
+                // 目標ノードは cur の右部分木にある
+                Ordering::Greater => cur = node.borrow().right.clone(),
+                // 目標ノードは cur の左部分木にある
+                Ordering::Less => cur = node.borrow().left.clone(),
+                // 目標ノードが見つかったらループを抜ける
+                Ordering::Equal => break,
+            }
+        }
+
+        // 目標ノードを返す
+        cur
+    }
+
+    /* ノードを挿入 */
+    pub fn insert(&mut self, num: i32) {
+        // 木が空なら、根ノードを初期化する
+        if self.root.is_none() {
+            self.root = Some(TreeNode::new(num));
+            return;
+        }
+        let mut cur = self.root.clone();
+        let mut pre = None;
+        // ループで探索し、葉ノードを越えたら抜ける
+        while let Some(node) = cur.clone() {
+            match num.cmp(&node.borrow().val) {
+                // 重複ノードが見つかったら、直ちに返す
+                Ordering::Equal => return,
+                // 挿入位置は cur の右部分木にある
+                Ordering::Greater => {
+                    pre = cur.clone();
+                    cur = node.borrow().right.clone();
+                }
+                // 挿入位置は cur の左部分木にある
+                Ordering::Less => {
+                    pre = cur.clone();
+                    cur = node.borrow().left.clone();
+                }
+            }
+        }
+        // ノードを挿入
+        let pre = pre.unwrap();
+        let node = Some(TreeNode::new(num));
+        if num > pre.borrow().val {
+            pre.borrow_mut().right = node;
+        } else {
+            pre.borrow_mut().left = node;
+        }
+    }
+
+    /* ノードを削除 */
+    pub fn remove(&mut self, num: i32) {
+        // 木が空なら、そのまま早期リターンする
+        if self.root.is_none() {
+            return;
+        }
+        let mut cur = self.root.clone();
+        let mut pre = None;
+        // ループで探索し、葉ノードを越えたら抜ける
+        while let Some(node) = cur.clone() {
+            match num.cmp(&node.borrow().val) {
+                // 削除対象のノードが見つかったら、ループを抜ける
+                Ordering::Equal => break,
+                // 削除対象ノードは cur の右部分木にある
+                Ordering::Greater => {
+                    pre = cur.clone();
+                    cur = node.borrow().right.clone();
+                }
+                // 削除対象ノードは cur の左部分木にある
+                Ordering::Less => {
+                    pre = cur.clone();
+                    cur = node.borrow().left.clone();
+                }
+            }
+        }
+        // 削除対象ノードがなければそのまま返す
+        if cur.is_none() {
+            return;
+        }
+        let cur = cur.unwrap();
+        let (left_child, right_child) = (cur.borrow().left.clone(), cur.borrow().right.clone());
+        match (left_child.clone(), right_child.clone()) {
+            // 子ノード数 = 0 or 1
+            (None, None) | (Some(_), None) | (None, Some(_)) => {
+                // 子ノード数 = 0 / 1 のとき、child = nullptr / その子ノード
+                let child = left_child.or(right_child);
+                let pre = pre.unwrap();
+                // ノード cur を削除する
+                if !Rc::ptr_eq(&cur, self.root.as_ref().unwrap()) {
+                    let left = pre.borrow().left.clone();
+                    if left.is_some() && Rc::ptr_eq(left.as_ref().unwrap(), &cur) {
+                        pre.borrow_mut().left = child;
+                    } else {
+                        pre.borrow_mut().right = child;
+                    }
+                } else {
+                    // 削除ノードが根ノードなら、根ノードを再設定
+                    self.root = child;
+                }
+            }
+            // 子ノード数 = 2
+            (Some(_), Some(_)) => {
+                // 中順走査における cur の次ノードを取得
+                let mut tmp = cur.borrow().right.clone();
+                while let Some(node) = tmp.clone() {
+                    if node.borrow().left.is_some() {
+                        tmp = node.borrow().left.clone();
+                    } else {
+                        break;
+                    }
+                }
+                let tmp_val = tmp.unwrap().borrow().val;
+                // ノード tmp を再帰的に削除
+                self.remove(tmp_val);
+                // tmp で cur を上書きする
+                cur.borrow_mut().val = tmp_val;
+            }
+        }
+    }
+}
+
+/* Driver Code */
+fn main() {
+    /* 二分探索木を初期化 */
+    let mut bst = BinarySearchTree::new();
+    // 注意：挿入順序が異なると異なる二分木が生成される。このシーケンスからは完全二分木を生成できる
+    let nums = [8, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13, 15];
+    for &num in &nums {
+        bst.insert(num);
+    }
+    println!("\n初期化した二分木は\n");
+    print_util::print_tree(bst.get_root().as_ref().unwrap());
+
+    /* ノードを検索 */
+    let node = bst.search(7);
+    println!(
+        "\n見つかったノードオブジェクトは {:?}、ノードの値 = {}",
+        node.clone().unwrap(),
+        node.clone().unwrap().borrow().val
+    );
+
+    /* ノードを挿入 */
+    bst.insert(16);
+    println!("\nノード 16 を挿入した後、二分木は\n");
+    print_util::print_tree(bst.get_root().as_ref().unwrap());
+
+    /* ノードを削除 */
+    bst.remove(1);
+    println!("\nノード 1 を削除した後、二分木は\n");
+    print_util::print_tree(bst.get_root().as_ref().unwrap());
+    bst.remove(2);
+    println!("\nノード 2 を削除した後、二分木は\n");
+    print_util::print_tree(bst.get_root().as_ref().unwrap());
+    bst.remove(4);
+    println!("\nノード 4 を削除した後、二分木は\n");
+    print_util::print_tree(bst.get_root().as_ref().unwrap());
+}

ja/codes/rust/chapter_tree/binary_tree.rs

@@ -0,0 +1,38 @@
+/**
+ * File: binary_tree.rs
+ * Created Time: 2023-02-27
+ * Author: xBLACKICEx (xBLACKICE@outlook.com)
+ */
+use std::rc::Rc;
+use hello_algo_rust::include::{print_util, TreeNode};
+
+/* Driver Code */
+fn main() {
+    /* 二分木を初期化 */
+    // ノードを初期化
+    let n1 = TreeNode::new(1);
+    let n2 = TreeNode::new(2);
+    let n3 = TreeNode::new(3);
+    let n4 = TreeNode::new(4);
+    let n5 = TreeNode::new(5);
+    // ノード間の参照（ポインタ）を構築する
+    n1.borrow_mut().left = Some(Rc::clone(&n2));
+    n1.borrow_mut().right = Some(Rc::clone(&n3));
+    n2.borrow_mut().left = Some(Rc::clone(&n4));
+    n2.borrow_mut().right = Some(Rc::clone(&n5));
+    println!("\n二分木を初期化\n");
+    print_util::print_tree(&n1);
+
+    // ノードの挿入と削除
+    let p = TreeNode::new(0);
+    // n1 -> n2 の間にノード P を挿入
+    p.borrow_mut().left = Some(Rc::clone(&n2));
+    n1.borrow_mut().left = Some(Rc::clone(&p));
+    println!("\nノード P を挿入した後\n");
+    print_util::print_tree(&n1);
+    // ノード P を削除
+    drop(p);
+    n1.borrow_mut().left = Some(Rc::clone(&n2));
+    println!("\nノード P を削除した後\n");
+    print_util::print_tree(&n1);
+}

ja/codes/rust/chapter_tree/binary_tree_bfs.rs

@@ -0,0 +1,45 @@
+/*
+ * File: binary_tree_bfs.rs
+ * Created Time: 2023-04-07
+ * Author: xBLACKICEx (xBLACKICE@outlook.com)
+ */
+
+use hello_algo_rust::include::{print_util, vec_to_tree, TreeNode};
+use hello_algo_rust::op_vec;
+
+use std::collections::VecDeque;
+use std::{cell::RefCell, rc::Rc};
+
+/* レベル順走査 */
+fn level_order(root: &Rc<RefCell<TreeNode>>) -> Vec<i32> {
+    // キューを初期化し、ルートノードを追加する
+    let mut que = VecDeque::new();
+    que.push_back(root.clone());
+    // 走査順序を保存するためのリストを初期化する
+    let mut vec = Vec::new();
+
+    while let Some(node) = que.pop_front() {
+        // デキュー
+        vec.push(node.borrow().val); // ノードの値を保存する
+        if let Some(left) = node.borrow().left.as_ref() {
+            que.push_back(left.clone()); // 左子ノードをキューに追加
+        }
+        if let Some(right) = node.borrow().right.as_ref() {
+            que.push_back(right.clone()); // 右子ノードをキューに追加
+        };
+    }
+    vec
+}
+
+/* Driver Code */
+fn main() {
+    /* 二分木を初期化 */
+    // ここでは、配列から直接二分木を生成する関数を利用する
+    let root = vec_to_tree(op_vec![1, 2, 3, 4, 5, 6, 7]).unwrap();
+    println!("二分木を初期化\n");
+    print_util::print_tree(&root);
+
+    /* レベル順走査 */
+    let vec = level_order(&root);
+    print!("\nレベル順走査のノード出力シーケンス = {:?}", vec);
+}

ja/codes/rust/chapter_tree/binary_tree_dfs.rs

@@ -0,0 +1,87 @@
+/*
+ * File: binary_tree_dfs.rs
+ * Created Time: 2023-04-06
+ * Author: xBLACKICEx (xBLACKICE@outlook.com)
+ */
+
+use hello_algo_rust::include::{print_util, vec_to_tree, TreeNode};
+use hello_algo_rust::op_vec;
+
+use std::cell::RefCell;
+use std::rc::Rc;
+
+/* 先行順走査 */
+fn pre_order(root: Option<&Rc<RefCell<TreeNode>>>) -> Vec<i32> {
+    let mut result = vec![];
+
+    fn dfs(root: Option<&Rc<RefCell<TreeNode>>>, res: &mut Vec<i32>) {
+        if let Some(node) = root {
+            // 訪問順序：根ノード -> 左部分木 -> 右部分木
+            let node = node.borrow();
+            res.push(node.val);
+            dfs(node.left.as_ref(), res);
+            dfs(node.right.as_ref(), res);
+        }
+    }
+    dfs(root, &mut result);
+
+    result
+}
+
+/* 中順走査 */
+fn in_order(root: Option<&Rc<RefCell<TreeNode>>>) -> Vec<i32> {
+    let mut result = vec![];
+
+    fn dfs(root: Option<&Rc<RefCell<TreeNode>>>, res: &mut Vec<i32>) {
+        if let Some(node) = root {
+            // 訪問優先順: 左部分木 -> 根ノード -> 右部分木
+            let node = node.borrow();
+            dfs(node.left.as_ref(), res);
+            res.push(node.val);
+            dfs(node.right.as_ref(), res);
+        }
+    }
+    dfs(root, &mut result);
+
+    result
+}
+
+/* 後順走査 */
+fn post_order(root: Option<&Rc<RefCell<TreeNode>>>) -> Vec<i32> {
+    let mut result = vec![];
+
+    fn dfs(root: Option<&Rc<RefCell<TreeNode>>>, res: &mut Vec<i32>) {
+        if let Some(node) = root {
+            // 訪問優先順: 左部分木 -> 右部分木 -> 根ノード
+            let node = node.borrow();
+            dfs(node.left.as_ref(), res);
+            dfs(node.right.as_ref(), res);
+            res.push(node.val);
+        }
+    }
+
+    dfs(root, &mut result);
+
+    result
+}
+
+/* Driver Code */
+fn main() {
+    /* 二分木を初期化 */
+    // ここでは、配列から直接二分木を生成する関数を利用する
+    let root = vec_to_tree(op_vec![1, 2, 3, 4, 5, 6, 7]);
+    println!("二分木を初期化\n");
+    print_util::print_tree(root.as_ref().unwrap());
+
+    /* 先行順走査 */
+    let vec = pre_order(root.as_ref());
+    println!("\n前順走査のノード出力シーケンス = {:?}", vec);
+
+    /* 中順走査 */
+    let vec = in_order(root.as_ref());
+    println!("\n中順走査のノード出力シーケンス = {:?}", vec);
+
+    /* 後順走査 */
+    let vec = post_order(root.as_ref());
+    print!("\n後順走査のノード出力シーケンス = {:?}", vec);
+}