Add ru version (#1865)

* Add Russian docs site baseline

* Add Russian localized codebase

* Polish Russian code wording

* Update ru code translation.

* Update code translation and chapter covers.

* Fix pythontutor extraction.

* Add README and landing page.

* placeholder of profiles

* Use figures of English version

* Remove chapter paperbook

ru/codes/rust/chapter_tree/array_binary_tree.rs

@@ -0,0 +1,186 @@
+/*
+ * 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Текущий индекс узла = {}, значение = {}",\ni,\nif let Some(val) = abt.val(i) {\n    format!("{val}")\n} else {\n    "null".to_string()\n}
+    );
+    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);
+}

ru/codes/rust/chapter_tree/avl_tree.rs

@@ -0,0 +1,295 @@
+/*
+ * 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();
+                // Выполнить правое вращение узла node вокруг child
+                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();
+                // Выполнить левое вращение узла node вокруг child
+                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Найденный объект узла = {:?}, значение узла = {}",\n&*node.borrow(),\nnode.borrow().val
+        );
+    }
+}

ru/codes/rust/chapter_tree/binary_search_tree.rs

@@ -0,0 +1,193 @@
+/*
+ * 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 или 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);
+                // Перезаписать cur значением tmp
+                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Найденный объект узла = {:?}, значение узла = {}",\nnode.clone().unwrap(),\nnode.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());
+}

ru/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);
+    // Вставить узел P между n1 -> n2
+    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);
+}

ru/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);
+}

ru/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);
+}