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/kotlin/utils/ListNode.kt

@@ -0,0 +1,25 @@
+/**
+ * File: ListNode.kt
+ * Created Time: 2024-01-25
+ * Author: curtishd (1023632660@qq.com)
+ */
+
+package utils
+
+/* Узел связного списка */
+class ListNode(var _val: Int) {
+    var next: ListNode? = null
+
+    companion object {
+        /* Десериализовать список в связный список */
+        fun arrToLinkedList(arr: IntArray): ListNode? {
+            val dum = ListNode(0)
+            var head = dum
+            for (_val in arr) {
+                head.next = ListNode(_val)
+                head = head.next!!
+            }
+            return dum.next
+        }
+    }
+}

ru/codes/kotlin/utils/PrintUtil.kt

@@ -0,0 +1,107 @@
+/**
+ * File: PrintUtil.kt
+ * Created Time: 2024-01-25
+ * Author: curtishd (1023632660@qq.com)
+ */
+
+package utils
+
+import java.util.*
+
+class Trunk(var prev: Trunk?, var str: String)
+
+/* Вывести матрицу (Array) */
+fun <T> printMatrix(matrix: Array<Array<T>>) {
+    println("[")
+    for (row in matrix) {
+        println("  $row,")
+    }
+    println("]")
+}
+
+/* Вывести матрицу (List) */
+fun <T> printMatrix(matrix: MutableList<MutableList<T>>) {
+    println("[")
+    for (row in matrix) {
+        println("  $row,")
+    }
+    println("]")
+}
+
+/* Вывести связный список */
+fun printLinkedList(h: ListNode?) {
+    var head = h
+    val list = mutableListOf<String>()
+    while (head != null) {
+        list.add(head._val.toString())
+        head = head.next
+    }
+    println(list.joinToString(separator = " -> "))
+}
+
+/* Вывести двоичное дерево */
+fun printTree(root: TreeNode?) {
+    printTree(root, null, false)
+}
+
+/**
+ * Вывести двоичное дерево
+ * Этот вывод дерева заимствован из TECHIE DELIGHT
+ * https://www.techiedelight.com/c-program-print-binary-tree/
+ */
+fun printTree(root: TreeNode?, prev: Trunk?, isRight: Boolean) {
+    if (root == null) {
+        return
+    }
+
+    var prevStr = "    "
+    val trunk = Trunk(prev, prevStr)
+
+    printTree(root.right, trunk, true)
+
+    if (prev == null) {
+        trunk.str = "———"
+    } else if (isRight) {
+        trunk.str = "/———"
+        prevStr = "   |"
+    } else {
+        trunk.str = "\\———"
+        prev.str = prevStr
+    }
+
+    showTrunks(trunk)
+    println(" ${root._val}")
+
+    if (prev != null) {
+        prev.str = prevStr
+    }
+    trunk.str = "   |"
+
+    printTree(root.left, trunk, false)
+}
+
+fun showTrunks(p: Trunk?) {
+    if (p == null) {
+        return
+    }
+    showTrunks(p.prev)
+    print(p.str)
+}
+
+/* Вывести хеш-таблицу */
+fun <K, V> printHashMap(map: Map<K, V>) {
+    for ((key, value) in map) {
+        println("${key.toString()} -> $value")
+    }
+}
+
+/* Вывести кучу */
+fun printHeap(queue: Queue<Int>?) {
+    val list = mutableListOf<Int?>()
+    queue?.let { list.addAll(it) }
+    print("Массивное представление кучи:")
+    println(list)
+    println("Древовидное представление кучи:")
+    val root = TreeNode.listToTree(list)
+    printTree(root)
+}

ru/codes/kotlin/utils/TreeNode.kt

@@ -0,0 +1,69 @@
+/**
+ * File: TreeNode.kt
+ * Created Time: 2024-01-25
+ * Author: curtishd (1023632660@qq.com)
+ */
+
+package utils
+
+/* Класс узла двоичного дерева */
+/* Конструктор */
+class TreeNode(
+    var _val: Int // Значение узла
+) {
+    var height: Int = 0 // Высота узла
+    var left: TreeNode? = null // Ссылка на левый дочерний узел
+    var right: TreeNode? = null // Ссылка на правый дочерний узел
+
+    // Правила кодирования сериализации см.:
+    // https://www.hello-algo.com/chapter_tree/array_representation_of_tree/
+    // Массивное представление двоичного дерева:
+    // [1, 2, 3, 4, None, 6, 7, 8, 9, None, None, 12, None, None, 15]
+    // Связное представление двоичного дерева:
+    // /——— 15
+    // /——— 7
+    // /——— 3
+    // |    \——— 6
+    // |        \——— 12
+    // ——— 1
+    // \——— 2
+    // |    /——— 9
+    // \——— 4
+    // \——— 8
+
+    /* Десериализовать список в двоичное дерево: рекурсия */
+    companion object {
+        private fun listToTreeDFS(arr: MutableList<Int?>, i: Int): TreeNode? {
+            if (i < 0 || i >= arr.size || arr[i] == null) {
+                return null
+            }
+            val root = TreeNode(arr[i]!!)
+            root.left = listToTreeDFS(arr, 2 * i + 1)
+            root.right = listToTreeDFS(arr, 2 * i + 2)
+            return root
+        }
+
+        /* Десериализовать список в двоичное дерево */
+        fun listToTree(arr: MutableList<Int?>): TreeNode? {
+            return listToTreeDFS(arr, 0)
+        }
+
+        /* Сериализовать двоичное дерево в список: рекурсия */
+        private fun treeToListDFS(root: TreeNode?, i: Int, res: MutableList<Int?>) {
+            if (root == null) return
+            while (i >= res.size) {
+                res.add(null)
+            }
+            res[i] = root._val
+            treeToListDFS(root.left, 2 * i + 1, res)
+            treeToListDFS(root.right, 2 * i + 2, res)
+        }
+
+        /* Сериализовать двоичное дерево в список */
+        fun treeToList(root: TreeNode?): MutableList<Int?> {
+            val res = mutableListOf<Int?>()
+            treeToListDFS(root, 0, res)
+            return res
+        }
+    }
+}

ru/codes/kotlin/utils/Vertex.kt

@@ -0,0 +1,30 @@
+/**
+ * File: Vertex.kt
+ * Created Time: 2024-01-25
+ * Author: curtishd (1023632660@qq.com)
+ */
+
+package utils
+
+/* Класс вершины */
+class Vertex(val _val: Int) {
+    companion object {
+        /* На вход подается список значений vals, на выходе возвращается список вершин vets */
+        fun valsToVets(vals: IntArray): Array<Vertex?> {
+            val vets = arrayOfNulls<Vertex>(vals.size)
+            for (i in vals.indices) {
+                vets[i] = Vertex(vals[i])
+            }
+            return vets
+        }
+
+        /* На вход подается список вершин vets, на выходе возвращается список значений vals */
+        fun vetsToVals(vets: MutableList<Vertex?>): MutableList<Int> {
+            val vals = mutableListOf<Int>()
+            for (vet in vets) {
+                vals.add(vet!!._val)
+            }
+            return vals
+        }
+    }
+}