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/java/chapter_tree/array_binary_tree.java

@@ -0,0 +1,136 @@
+/**
+ * File: array_binary_tree.java
+ * Created Time: 2023-07-19
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_tree;
+
+import utils.*;
+import java.util.*;
+
+/* Класс двоичного дерева в массивном представлении */
+class ArrayBinaryTree {
+    private List<Integer> tree;
+
+    /* Конструктор */
+    public ArrayBinaryTree(List<Integer> arr) {
+        tree = new ArrayList<>(arr);
+    }
+
+    /* Вместимость списка */
+    public int size() {
+        return tree.size();
+    }
+
+    /* Получить значение узла с индексом i */
+    public Integer val(int i) {
+        // Если индекс выходит за границы, вернуть null, обозначающий пустую позицию
+        if (i < 0 || i >= size())
+            return null;
+        return tree.get(i);
+    }
+
+    /* Получить индекс левого дочернего узла узла с индексом i */
+    public Integer left(int i) {
+        return 2 * i + 1;
+    }
+
+    /* Получить индекс правого дочернего узла узла с индексом i */
+    public Integer right(int i) {
+        return 2 * i + 2;
+    }
+
+    /* Получить индекс родительского узла узла с индексом i */
+    public Integer parent(int i) {
+        return (i - 1) / 2;
+    }
+
+    /* Обход в ширину */
+    public List<Integer> levelOrder() {
+        List<Integer> res = new ArrayList<>();
+        // Непосредственно обходить массив
+        for (int i = 0; i < size(); i++) {
+            if (val(i) != null)
+                res.add(val(i));
+        }
+        return res;
+    }
+
+    /* Обход в глубину */
+    private void dfs(Integer i, String order, List<Integer> res) {
+        // Если это пустая позиция, вернуть
+        if (val(i) == null)
+            return;
+        // Предварительный обход
+        if ("pre".equals(order))
+            res.add(val(i));
+        dfs(left(i), order, res);
+        // Симметричный обход
+        if ("in".equals(order))
+            res.add(val(i));
+        dfs(right(i), order, res);
+        // Обратный обход
+        if ("post".equals(order))
+            res.add(val(i));
+    }
+
+    /* Предварительный обход */
+    public List<Integer> preOrder() {
+        List<Integer> res = new ArrayList<>();
+        dfs(0, "pre", res);
+        return res;
+    }
+
+    /* Симметричный обход */
+    public List<Integer> inOrder() {
+        List<Integer> res = new ArrayList<>();
+        dfs(0, "in", res);
+        return res;
+    }
+
+    /* Обратный обход */
+    public List<Integer> postOrder() {
+        List<Integer> res = new ArrayList<>();
+        dfs(0, "post", res);
+        return res;
+    }
+}
+
+public class array_binary_tree {
+    public static void main(String[] args) {
+        // Инициализировать двоичное дерево
+        // Здесь используется функция, напрямую строящая двоичное дерево из массива
+        List<Integer> arr = Arrays.asList(1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15);
+
+        TreeNode root = TreeNode.listToTree(arr);
+        System.out.println("\nИнициализация двоичного дерева\n");
+        System.out.println("Массивное представление двоичного дерева:");
+        System.out.println(arr);
+        System.out.println("Связное представление двоичного дерева:");
+        PrintUtil.printTree(root);
+
+        // Класс двоичного дерева в массивном представлении
+        ArrayBinaryTree abt = new ArrayBinaryTree(arr);
+
+        // Доступ к узлу
+        int i = 1;
+        Integer l = abt.left(i);
+        Integer r = abt.right(i);
+        Integer p = abt.parent(i);
+        System.out.println("\nТекущий узел: индекс = " + i + " , значение = " + abt.val(i));
+        System.out.println("Индекс левого дочернего узла = " + l + " , значение = " + (l == null ? "null" : abt.val(l)));
+        System.out.println("Индекс правого дочернего узла = " + r + " , значение = " + (r == null ? "null" : abt.val(r)));
+        System.out.println("Индекс родительского узла = " + p + " , значение = " + (p == null ? "null" : abt.val(p)));
+
+        // Обходить дерево
+        List<Integer> res = abt.levelOrder();
+        System.out.println("\nОбход в ширину =" + res);
+        res = abt.preOrder();
+        System.out.println("Предварительный обход =" + res);
+        res = abt.inOrder();
+        System.out.println("Симметричный обход =" + res);
+        res = abt.postOrder();
+        System.out.println("Обратный обход =" + res);
+    }
+}

ru/codes/java/chapter_tree/avl_tree.java

@@ -0,0 +1,220 @@
+/**
+ * File: avl_tree.java
+ * Created Time: 2022-12-10
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_tree;
+
+import utils.*;
+
+/* AVL-дерево */
+class AVLTree {
+    TreeNode root; // Корневой узел
+
+    /* Получить высоту узла */
+    public int height(TreeNode node) {
+        // Высота пустого узла равна -1, высота листового узла равна 0
+        return node == null ? -1 : node.height;
+    }
+
+    /* Обновить высоту узла */
+    private void updateHeight(TreeNode node) {
+        // Высота узла равна высоте более высокого поддерева + 1
+        node.height = Math.max(height(node.left), height(node.right)) + 1;
+    }
+
+    /* Получить коэффициент баланса */
+    public int balanceFactor(TreeNode node) {
+        // Коэффициент баланса пустого узла равен 0
+        if (node == null)
+            return 0;
+        // Коэффициент баланса узла = высота левого поддерева - высота правого поддерева
+        return height(node.left) - height(node.right);
+    }
+
+    /* Операция правого вращения */
+    private TreeNode rightRotate(TreeNode node) {
+        TreeNode child = node.left;
+        TreeNode grandChild = child.right;
+        // Выполнить правое вращение узла node вокруг child
+        child.right = node;
+        node.left = grandChild;
+        // Обновить высоту узла
+        updateHeight(node);
+        updateHeight(child);
+        // Вернуть корневой узел поддерева после вращения
+        return child;
+    }
+
+    /* Операция левого вращения */
+    private TreeNode leftRotate(TreeNode node) {
+        TreeNode child = node.right;
+        TreeNode grandChild = child.left;
+        // Выполнить левое вращение узла node вокруг child
+        child.left = node;
+        node.right = grandChild;
+        // Обновить высоту узла
+        updateHeight(node);
+        updateHeight(child);
+        // Вернуть корневой узел поддерева после вращения
+        return child;
+    }
+
+    /* Выполнить вращение, чтобы снова сбалансировать поддерево */
+    private TreeNode rotate(TreeNode node) {
+        // Получить коэффициент баланса узла node
+        int balanceFactor = balanceFactor(node);
+        // Левосторонне перекошенное дерево
+        if (balanceFactor > 1) {
+            if (balanceFactor(node.left) >= 0) {
+                // Правое вращение
+                return rightRotate(node);
+            } else {
+                // Сначала левое вращение, затем правое
+                node.left = leftRotate(node.left);
+                return rightRotate(node);
+            }
+        }
+        // Правосторонне перекошенное дерево
+        if (balanceFactor < -1) {
+            if (balanceFactor(node.right) <= 0) {
+                // Левое вращение
+                return leftRotate(node);
+            } else {
+                // Сначала правое вращение, затем левое
+                node.right = rightRotate(node.right);
+                return leftRotate(node);
+            }
+        }
+        // Дерево сбалансировано, вращение не требуется, вернуть сразу
+        return node;
+    }
+
+    /* Вставка узла */
+    public void insert(int val) {
+        root = insertHelper(root, val);
+    }
+
+    /* Рекурсивная вставка узла (вспомогательный метод) */
+    private TreeNode insertHelper(TreeNode node, int val) {
+        if (node == null)
+            return new TreeNode(val);
+        /* 1. Найти позицию вставки и вставить узел */
+        if (val < node.val)
+            node.left = insertHelper(node.left, val);
+        else if (val > node.val)
+            node.right = insertHelper(node.right, val);
+        else
+            return node; // Повторяющийся узел не вставлять, сразу вернуть
+        updateHeight(node); // Обновить высоту узла
+        /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */
+        node = rotate(node);
+        // Вернуть корневой узел поддерева
+        return node;
+    }
+
+    /* Удаление узла */
+    public void remove(int val) {
+        root = removeHelper(root, val);
+    }
+
+    /* Рекурсивное удаление узла (вспомогательный метод) */
+    private TreeNode removeHelper(TreeNode node, int val) {
+        if (node == null)
+            return null;
+        /* 1. Найти узел и удалить его */
+        if (val < node.val)
+            node.left = removeHelper(node.left, val);
+        else if (val > node.val)
+            node.right = removeHelper(node.right, val);
+        else {
+            if (node.left == null || node.right == null) {
+                TreeNode child = node.left != null ? node.left : node.right;
+                // Число дочерних узлов = 0, удалить node и сразу вернуть
+                if (child == null)
+                    return null;
+                // Число дочерних узлов = 1, удалить node напрямую
+                else
+                    node = child;
+            } else {
+                // Число дочерних узлов = 2, удалить следующий по симметричному обходу узел и заменить им текущий узел
+                TreeNode temp = node.right;
+                while (temp.left != null) {
+                    temp = temp.left;
+                }
+                node.right = removeHelper(node.right, temp.val);
+                node.val = temp.val;
+            }
+        }
+        updateHeight(node); // Обновить высоту узла
+        /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */
+        node = rotate(node);
+        // Вернуть корневой узел поддерева
+        return node;
+    }
+
+    /* Поиск узла */
+    public TreeNode search(int val) {
+        TreeNode cur = root;
+        // Искать в цикле и выйти после прохода за листовой узел
+        while (cur != null) {
+            // Целевой узел находится в правом поддереве cur
+            if (cur.val < val)
+                cur = cur.right;
+            // Целевой узел находится в левом поддереве cur
+            else if (cur.val > val)
+                cur = cur.left;
+            // Найти целевой узел и выйти из цикла
+            else
+                break;
+        }
+        // Вернуть целевой узел
+        return cur;
+    }
+}
+
+public class avl_tree {
+    static void testInsert(AVLTree tree, int val) {
+        tree.insert(val);
+        System.out.println("\nПосле вставки узла " + val + " AVL-дерево имеет вид");
+        PrintUtil.printTree(tree.root);
+    }
+
+    static void testRemove(AVLTree tree, int val) {
+        tree.remove(val);
+        System.out.println("\nПосле удаления узла " + val + " AVL-дерево имеет вид");
+        PrintUtil.printTree(tree.root);
+    }
+
+    public static void main(String[] args) {
+        /* Инициализация пустого AVL-дерева */
+        AVLTree avlTree = new AVLTree();
+
+        /* Вставка узла */
+        // Обратите внимание, как AVL-дерево сохраняет баланс после вставки узла
+        testInsert(avlTree, 1);
+        testInsert(avlTree, 2);
+        testInsert(avlTree, 3);
+        testInsert(avlTree, 4);
+        testInsert(avlTree, 5);
+        testInsert(avlTree, 8);
+        testInsert(avlTree, 7);
+        testInsert(avlTree, 9);
+        testInsert(avlTree, 10);
+        testInsert(avlTree, 6);
+
+        /* Вставка повторяющегося узла */
+        testInsert(avlTree, 7);
+
+        /* Удаление узла */
+        // Обратите внимание, как AVL-дерево сохраняет баланс после удаления узла
+        testRemove(avlTree, 8); // Удаление узла степени 0
+        testRemove(avlTree, 5); // Удаление узла степени 1
+        testRemove(avlTree, 4); // Удаление узла степени 2
+
+        /* Поиск узла */
+        TreeNode node = avlTree.search(7);
+        System.out.println("\nНайденный объект узла = " + node + ", значение узла = " + node.val);
+    }
+}

ru/codes/java/chapter_tree/binary_search_tree.java

@@ -0,0 +1,158 @@
+/**
+ * File: binary_search_tree.java
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_tree;
+
+import utils.*;
+
+/* Двоичное дерево поиска */
+class BinarySearchTree {
+    private TreeNode root;
+
+    /* Конструктор */
+    public BinarySearchTree() {
+        // Инициализировать пустое дерево
+        root = null;
+    }
+
+    /* Получить корневой узел двоичного дерева */
+    public TreeNode getRoot() {
+        return root;
+    }
+
+    /* Поиск узла */
+    public TreeNode search(int num) {
+        TreeNode cur = root;
+        // Искать в цикле и выйти после прохода за листовой узел
+        while (cur != null) {
+            // Целевой узел находится в правом поддереве cur
+            if (cur.val < num)
+                cur = cur.right;
+            // Целевой узел находится в левом поддереве cur
+            else if (cur.val > num)
+                cur = cur.left;
+            // Найти целевой узел и выйти из цикла
+            else
+                break;
+        }
+        // Вернуть целевой узел
+        return cur;
+    }
+
+    /* Вставка узла */
+    public void insert(int num) {
+        // Если дерево пусто, инициализировать корневой узел
+        if (root == null) {
+            root = new TreeNode(num);
+            return;
+        }
+        TreeNode cur = root, pre = null;
+        // Искать в цикле и выйти после прохода за листовой узел
+        while (cur != null) {
+            // Найти повторяющийся узел и сразу вернуть
+            if (cur.val == num)
+                return;
+            pre = cur;
+            // Позиция вставки находится в правом поддереве cur
+            if (cur.val < num)
+                cur = cur.right;
+            // Позиция вставки находится в левом поддереве cur
+            else
+                cur = cur.left;
+        }
+        // Вставка узла
+        TreeNode node = new TreeNode(num);
+        if (pre.val < num)
+            pre.right = node;
+        else
+            pre.left = node;
+    }
+
+    /* Удаление узла */
+    public void remove(int num) {
+        // Если дерево пусто, сразу вернуть
+        if (root == null)
+            return;
+        TreeNode cur = root, pre = null;
+        // Искать в цикле и выйти после прохода за листовой узел
+        while (cur != null) {
+            // Найти узел для удаления и выйти из цикла
+            if (cur.val == num)
+                break;
+            pre = cur;
+            // Узел для удаления находится в правом поддереве cur
+            if (cur.val < num)
+                cur = cur.right;
+            // Узел для удаления находится в левом поддереве cur
+            else
+                cur = cur.left;
+        }
+        // Если узел для удаления отсутствует, сразу вернуть
+        if (cur == null)
+            return;
+        // Число дочерних узлов = 0 или 1
+        if (cur.left == null || cur.right == null) {
+            // Когда число дочерних узлов = 0 / 1, child = null / этот дочерний узел
+            TreeNode child = cur.left != null ? cur.left : cur.right;
+            // Удалить узел cur
+            if (cur != root) {
+                if (pre.left == cur)
+                    pre.left = child;
+                else
+                    pre.right = child;
+            } else {
+                // Если удаляемый узел является корнем, заново назначить корневой узел
+                root = child;
+            }
+        }
+        // Число дочерних узлов = 2
+        else {
+            // Получить следующий узел после cur в симметричном обходе
+            TreeNode tmp = cur.right;
+            while (tmp.left != null) {
+                tmp = tmp.left;
+            }
+            // Рекурсивно удалить узел tmp
+            remove(tmp.val);
+            // Перезаписать cur значением tmp
+            cur.val = tmp.val;
+        }
+    }
+}
+
+public class binary_search_tree {
+    public static void main(String[] args) {
+        /* Инициализация двоичного дерева поиска */
+        BinarySearchTree bst = new BinarySearchTree();
+        // Обратите внимание: разные порядки вставки порождают разные двоичные деревья; данная последовательность может построить совершенное двоичное дерево
+        int[] nums = { 8, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13, 15 };
+        for (int num : nums) {
+            bst.insert(num);
+        }
+        System.out.println("\nИсходное двоичное дерево\n");
+        PrintUtil.printTree(bst.getRoot());
+
+        /* Поиск узла */
+        TreeNode node = bst.search(7);
+        System.out.println("\nНайденный объект узла = " + node + ", значение узла = " + node.val);
+
+        /* Вставка узла */
+        bst.insert(16);
+        System.out.println("\nПосле вставки узла 16 двоичное дерево имеет вид\n");
+        PrintUtil.printTree(bst.getRoot());
+
+        /* Удаление узла */
+        bst.remove(1);
+        System.out.println("\nПосле удаления узла 1 двоичное дерево имеет вид\n");
+        PrintUtil.printTree(bst.getRoot());
+        bst.remove(2);
+        System.out.println("\nПосле удаления узла 2 двоичное дерево имеет вид\n");
+        PrintUtil.printTree(bst.getRoot());
+        bst.remove(4);
+        System.out.println("\nПосле удаления узла 4 двоичное дерево имеет вид\n");
+        PrintUtil.printTree(bst.getRoot());
+    }
+}

ru/codes/java/chapter_tree/binary_tree.java

@@ -0,0 +1,40 @@
+/**
+ * File: binary_tree.java
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_tree;
+
+import utils.*;
+
+public class binary_tree {
+    public static void main(String[] args) {
+        /* Инициализация двоичного дерева */
+        // Инициализация узла
+        TreeNode n1 = new TreeNode(1);
+        TreeNode n2 = new TreeNode(2);
+        TreeNode n3 = new TreeNode(3);
+        TreeNode n4 = new TreeNode(4);
+        TreeNode n5 = new TreeNode(5);
+        // Построить связи между узлами (указатели)
+        n1.left = n2;
+        n1.right = n3;
+        n2.left = n4;
+        n2.right = n5;
+        System.out.println("\nИнициализация двоичного дерева\n");
+        PrintUtil.printTree(n1);
+
+        /* Вставка и удаление узлов */
+        TreeNode P = new TreeNode(0);
+        // Вставить узел P между n1 -> n2
+        n1.left = P;
+        P.left = n2;
+        System.out.println("\nПосле вставки узла P\n");
+        PrintUtil.printTree(n1);
+        // Удалить узел P
+        n1.left = n2;
+        System.out.println("\nПосле удаления узла P\n");
+        PrintUtil.printTree(n1);
+    }
+}

ru/codes/java/chapter_tree/binary_tree_bfs.java

@@ -0,0 +1,42 @@
+/**
+ * File: binary_tree_bfs.java
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_tree;
+
+import utils.*;
+import java.util.*;
+
+public class binary_tree_bfs {
+    /* Обход в ширину */
+    static List<Integer> levelOrder(TreeNode root) {
+        // Инициализировать очередь и добавить корневой узел
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.add(root);
+        // Инициализировать список для хранения последовательности обхода
+        List<Integer> list = new ArrayList<>();
+        while (!queue.isEmpty()) {
+            TreeNode node = queue.poll(); // Извлечение из очереди
+            list.add(node.val);           // Сохранить значение узла
+            if (node.left != null)
+                queue.offer(node.left);   // Поместить левый дочерний узел в очередь
+            if (node.right != null)
+                queue.offer(node.right);  // Поместить правый дочерний узел в очередь
+        }
+        return list;
+    }
+
+    public static void main(String[] args) {
+        /* Инициализация двоичного дерева */
+        // Здесь используется функция, напрямую строящая двоичное дерево из массива
+        TreeNode root = TreeNode.listToTree(Arrays.asList(1, 2, 3, 4, 5, 6, 7));
+        System.out.println("\nИнициализация двоичного дерева\n");
+        PrintUtil.printTree(root);
+
+        /* Обход в ширину */
+        List<Integer> list = levelOrder(root);
+        System.out.println("\nПоследовательность печати узлов при обходе в ширину = " + list);
+    }
+}

ru/codes/java/chapter_tree/binary_tree_dfs.java

@@ -0,0 +1,68 @@
+/**
+ * File: binary_tree_dfs.java
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_tree;
+
+import utils.*;
+import java.util.*;
+
+public class binary_tree_dfs {
+    // Инициализировать список для хранения последовательности обхода
+    static ArrayList<Integer> list = new ArrayList<>();
+
+    /* Предварительный обход */
+    static void preOrder(TreeNode root) {
+        if (root == null)
+            return;
+        // Порядок обхода: корень -> левое поддерево -> правое поддерево
+        list.add(root.val);
+        preOrder(root.left);
+        preOrder(root.right);
+    }
+
+    /* Симметричный обход */
+    static void inOrder(TreeNode root) {
+        if (root == null)
+            return;
+        // Порядок обхода: левое поддерево -> корень -> правое поддерево
+        inOrder(root.left);
+        list.add(root.val);
+        inOrder(root.right);
+    }
+
+    /* Обратный обход */
+    static void postOrder(TreeNode root) {
+        if (root == null)
+            return;
+        // Порядок обхода: левое поддерево -> правое поддерево -> корень
+        postOrder(root.left);
+        postOrder(root.right);
+        list.add(root.val);
+    }
+
+    public static void main(String[] args) {
+        /* Инициализация двоичного дерева */
+        // Здесь используется функция, напрямую строящая двоичное дерево из массива
+        TreeNode root = TreeNode.listToTree(Arrays.asList(1, 2, 3, 4, 5, 6, 7));
+        System.out.println("\nИнициализация двоичного дерева\n");
+        PrintUtil.printTree(root);
+
+        /* Предварительный обход */
+        list.clear();
+        preOrder(root);
+        System.out.println("\nПоследовательность печати узлов при предварительном обходе = " + list);
+
+        /* Симметричный обход */
+        list.clear();
+        inOrder(root);
+        System.out.println("\nПоследовательность печати узлов при симметричном обходе = " + list);
+
+        /* Обратный обход */
+        list.clear();
+        postOrder(root);
+        System.out.println("\nПоследовательность печати узлов при обратном обходе = " + list);
+    }
+}