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_heap/heap.rs

@@ -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();
+    // BinaryHeap в Rust является максимальной кучей; для минимальной кучи обычно используют оболочку Reverse
+    // Инициализировать максимальную кучу
+    let mut max_heap = BinaryHeap::new();
+
+    println!("\nНиже приведен тестовый пример для max-heap");
+
+    /* Добавление элемента в кучу */
+    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После построения min-heap из входного списка");
+    print_util::print_heap(min_heap.iter().map(|&val| val.0).collect());
+}

ru/codes/rust/chapter_heap/my_heap.rs

@@ -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 };
+        // Выполнить heapify для всех узлов, кроме листовых
+        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;
+            }
+            // Поменять два узла местами
+            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;
+            }
+            // Поменять два узла местами
+            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);
+}

ru/codes/rust/chapter_heap/top_k.rs

@@ -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());
+}