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/.gitignore

@@ -0,0 +1 @@
+build

ru/codes/java/chapter_array_and_linkedlist/array.java

@@ -0,0 +1,105 @@
+/**
+ * File: array.java
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_array_and_linkedlist;
+
+import java.util.*;
+import java.util.concurrent.ThreadLocalRandom;
+
+public class array {
+    /* Случайный доступ к элементу */
+    static int randomAccess(int[] nums) {
+        // Случайным образом выбрать число из интервала [0, nums.length)
+        int randomIndex = ThreadLocalRandom.current().nextInt(0, nums.length);
+        // Получить и вернуть случайный элемент
+        int randomNum = nums[randomIndex];
+        return randomNum;
+    }
+
+    /* Увеличить длину массива */
+    static int[] extend(int[] nums, int enlarge) {
+        // Инициализировать массив увеличенной длины
+        int[] res = new int[nums.length + enlarge];
+        // Скопировать все элементы исходного массива в новый массив
+        for (int i = 0; i < nums.length; i++) {
+            res[i] = nums[i];
+        }
+        // Вернуть новый массив после расширения
+        return res;
+    }
+
+    /* Вставить элемент num по индексу index в массив */
+    static void insert(int[] nums, int num, int index) {
+        // Сдвинуть элемент с индексом index и все последующие элементы на одну позицию назад
+        for (int i = nums.length - 1; i > index; i--) {
+            nums[i] = nums[i - 1];
+        }
+        // Присвоить num элементу по индексу index
+        nums[index] = num;
+    }
+
+    /* Удалить элемент по индексу index */
+    static void remove(int[] nums, int index) {
+        // Сдвинуть все элементы после индекса index на одну позицию вперед
+        for (int i = index; i < nums.length - 1; i++) {
+            nums[i] = nums[i + 1];
+        }
+    }
+
+    /* Обход массива */
+    static void traverse(int[] nums) {
+        int count = 0;
+        // Обход массива по индексам
+        for (int i = 0; i < nums.length; i++) {
+            count += nums[i];
+        }
+        // Непосредственно обходить элементы массива
+        for (int num : nums) {
+            count += num;
+        }
+    }
+
+    /* Найти заданный элемент в массиве */
+    static int find(int[] nums, int target) {
+        for (int i = 0; i < nums.length; i++) {
+            if (nums[i] == target)
+                return i;
+        }
+        return -1;
+    }
+
+    /* Driver Code */
+    public static void main(String[] args) {
+        /* Инициализация массива */
+        int[] arr = new int[5];
+        System.out.println("Массив arr = " + Arrays.toString(arr));
+        int[] nums = { 1, 3, 2, 5, 4 };
+        System.out.println("Массив nums = " + Arrays.toString(nums));
+
+        /* Случайный доступ */
+        int randomNum = randomAccess(nums);
+        System.out.println("Случайный элемент из nums = " + randomNum);
+
+        /* Расширение длины */
+        nums = extend(nums, 3);
+        System.out.println("После увеличения длины массива до 8 nums = " + Arrays.toString(nums));
+
+        /* Вставка элемента */
+        insert(nums, 6, 3);
+        System.out.println("После вставки числа 6 по индексу 3 nums = " + Arrays.toString(nums));
+
+        /* Удаление элемента */
+        remove(nums, 2);
+        System.out.println("После удаления элемента по индексу 2 nums = " + Arrays.toString(nums));
+
+        /* Обход массива */
+        traverse(nums);
+
+        /* Поиск элемента */
+        int index = find(nums, 3);
+        System.out.println("Поиск элемента 3 в nums: индекс = " + index);
+    }
+}

ru/codes/java/chapter_array_and_linkedlist/linked_list.java

@@ -0,0 +1,86 @@
+/**
+ * File: linked_list.java
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_array_and_linkedlist;
+
+import utils.*;
+
+public class linked_list {
+    /* Вставить узел P после узла n0 в связном списке */
+    static void insert(ListNode n0, ListNode P) {
+        ListNode n1 = n0.next;
+        P.next = n1;
+        n0.next = P;
+    }
+
+    /* Удалить первый узел после узла n0 в связном списке */
+    static void remove(ListNode n0) {
+        if (n0.next == null)
+            return;
+        // n0 -> P -> n1
+        ListNode P = n0.next;
+        ListNode n1 = P.next;
+        n0.next = n1;
+    }
+
+    /* Доступ к узлу связного списка по индексу index */
+    static ListNode access(ListNode head, int index) {
+        for (int i = 0; i < index; i++) {
+            if (head == null)
+                return null;
+            head = head.next;
+        }
+        return head;
+    }
+
+    /* Найти в связном списке первый узел со значением target */
+    static int find(ListNode head, int target) {
+        int index = 0;
+        while (head != null) {
+            if (head.val == target)
+                return index;
+            head = head.next;
+            index++;
+        }
+        return -1;
+    }
+
+    /* Driver Code */
+    public static void main(String[] args) {
+        /* Инициализация связного списка */
+        // Инициализация всех узлов
+        ListNode n0 = new ListNode(1);
+        ListNode n1 = new ListNode(3);
+        ListNode n2 = new ListNode(2);
+        ListNode n3 = new ListNode(5);
+        ListNode n4 = new ListNode(4);
+        // Построить ссылки между узлами
+        n0.next = n1;
+        n1.next = n2;
+        n2.next = n3;
+        n3.next = n4;
+        System.out.println("Исходный связный список");
+        PrintUtil.printLinkedList(n0);
+
+        /* Вставка узла */
+        insert(n0, new ListNode(0));
+        System.out.println("Связный список после вставки узла");
+        PrintUtil.printLinkedList(n0);
+
+        /* Удаление узла */
+        remove(n0);
+        System.out.println("Связный список после удаления узла");
+        PrintUtil.printLinkedList(n0);
+
+        /* Доступ к узлу */
+        ListNode node = access(n0, 3);
+        System.out.println("Значение узла по индексу 3 в связном списке = " + node.val);
+
+        /* Поиск узла */
+        int index = find(n0, 2);
+        System.out.println("Индекс узла со значением 2 в связном списке = " + index);
+    }
+}

ru/codes/java/chapter_array_and_linkedlist/list.java

@@ -0,0 +1,66 @@
+/**
+ * File: list.java
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_array_and_linkedlist;
+
+import java.util.*;
+
+public class list {
+    public static void main(String[] args) {
+        /* Инициализация списка */
+        // Обратите внимание: тип элементов массива int[] — это обертка Integer[]
+        Integer[] numbers = new Integer[] { 1, 3, 2, 5, 4 };
+        List<Integer> nums = new ArrayList<>(Arrays.asList(numbers));
+        System.out.println("Список nums = " + nums);
+
+        /* Доступ к элементу */
+        int num = nums.get(1);
+        System.out.println("Элемент по индексу 1: num = " + num);
+
+        /* Обновление элемента */
+        nums.set(1, 0);
+        System.out.println("После обновления элемента по индексу 1 до 0 nums = " + nums);
+
+        /* Очистить список */
+        nums.clear();
+        System.out.println("После очистки списка nums = " + nums);
+
+        /* Добавление элемента в конец */
+        nums.add(1);
+        nums.add(3);
+        nums.add(2);
+        nums.add(5);
+        nums.add(4);
+        System.out.println("После добавления элементов nums = " + nums);
+
+        /* Вставка элемента в середину */
+        nums.add(3, 6);
+        System.out.println("После вставки числа 6 по индексу 3 nums = " + nums);
+
+        /* Удаление элемента */
+        nums.remove(3);
+        System.out.println("После удаления элемента по индексу 3 nums = " + nums);
+
+        /* Обходить список по индексам */
+        int count = 0;
+        for (int i = 0; i < nums.size(); i++) {
+            count += nums.get(i);
+        }
+        /* Непосредственно обходить элементы списка */
+        for (int x : nums) {
+            count += x;
+        }
+
+        /* Объединить два списка */
+        List<Integer> nums1 = new ArrayList<>(Arrays.asList(new Integer[] { 6, 8, 7, 10, 9 }));
+        nums.addAll(nums1);
+        System.out.println("После конкатенации списка nums1 к nums nums = " + nums);
+
+        /* Отсортировать список */
+        Collections.sort(nums);
+        System.out.println("После сортировки списка nums = " + nums);
+    }
+}

ru/codes/java/chapter_array_and_linkedlist/my_list.java

@@ -0,0 +1,147 @@
+/**
+ * File: my_list.java
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_array_and_linkedlist;
+
+import java.util.*;
+
+/* Класс списка */
+class MyList {
+    private int[] arr; // Массив (для хранения элементов списка)
+    private int capacity = 10; // Вместимость списка
+    private int size = 0; // Длина списка (текущее число элементов)
+    private int extendRatio = 2; // Коэффициент увеличения списка при каждом расширении
+
+    /* Конструктор */
+    public MyList() {
+        arr = new int[capacity];
+    }
+
+    /* Получить длину списка (текущее число элементов) */
+    public int size() {
+        return size;
+    }
+
+    /* Получить вместимость списка */
+    public int capacity() {
+        return capacity;
+    }
+
+    /* Доступ к элементу */
+    public int get(int index) {
+        // Если индекс выходит за границы, выбрасывается исключение; далее аналогично
+        if (index < 0 || index >= size)
+            throw new IndexOutOfBoundsException("индекс выходит за границы");
+        return arr[index];
+    }
+
+    /* Обновление элемента */
+    public void set(int index, int num) {
+        if (index < 0 || index >= size)
+            throw new IndexOutOfBoundsException("индекс выходит за границы");
+        arr[index] = num;
+    }
+
+    /* Добавление элемента в конец */
+    public void add(int num) {
+        // При превышении вместимости по числу элементов запускается расширение
+        if (size == capacity())
+            extendCapacity();
+        arr[size] = num;
+        // Обновить число элементов
+        size++;
+    }
+
+    /* Вставка элемента в середину */
+    public void insert(int index, int num) {
+        if (index < 0 || index >= size)
+            throw new IndexOutOfBoundsException("индекс выходит за границы");
+        // При превышении вместимости по числу элементов запускается расширение
+        if (size == capacity())
+            extendCapacity();
+        // Сдвинуть элемент с индексом index и все следующие элементы на одну позицию назад
+        for (int j = size - 1; j >= index; j--) {
+            arr[j + 1] = arr[j];
+        }
+        arr[index] = num;
+        // Обновить число элементов
+        size++;
+    }
+
+    /* Удаление элемента */
+    public int remove(int index) {
+        if (index < 0 || index >= size)
+            throw new IndexOutOfBoundsException("индекс выходит за границы");
+        int num = arr[index];
+        // Сдвинуть все элементы после индекса index на одну позицию вперед
+        for (int j = index; j < size - 1; j++) {
+            arr[j] = arr[j + 1];
+        }
+        // Обновить число элементов
+        size--;
+        // Вернуть удаленный элемент
+        return num;
+    }
+
+    /* Расширение списка */
+    public void extendCapacity() {
+        // Создать новый массив длиной в extendRatio раз больше исходного и скопировать в него исходный массив
+        arr = Arrays.copyOf(arr, capacity() * extendRatio);
+        // Обновить вместимость списка
+        capacity = arr.length;
+    }
+
+    /* Преобразовать список в массив */
+    public int[] toArray() {
+        int size = size();
+        // Преобразовывать только элементы списка в пределах фактической длины
+        int[] arr = new int[size];
+        for (int i = 0; i < size; i++) {
+            arr[i] = get(i);
+        }
+        return arr;
+    }
+}
+
+public class my_list {
+    /* Driver Code */
+    public static void main(String[] args) {
+        /* Инициализация списка */
+        MyList nums = new MyList();
+        /* Добавление элемента в конец */
+        nums.add(1);
+        nums.add(3);
+        nums.add(2);
+        nums.add(5);
+        nums.add(4);
+        System.out.println("Список nums = " + Arrays.toString(nums.toArray()) +
+                ", вместимость = " + nums.capacity() + " , длина = " + nums.size());
+
+        /* Вставка элемента в середину */
+        nums.insert(3, 6);
+        System.out.println("После вставки числа 6 по индексу 3 nums = " + Arrays.toString(nums.toArray()));
+
+        /* Удаление элемента */
+        nums.remove(3);
+        System.out.println("После удаления элемента по индексу 3 nums = " + Arrays.toString(nums.toArray()));
+
+        /* Доступ к элементу */
+        int num = nums.get(1);
+        System.out.println("Элемент по индексу 1: num = " + num);
+
+        /* Обновление элемента */
+        nums.set(1, 0);
+        System.out.println("После обновления элемента по индексу 1 до 0 nums = " + Arrays.toString(nums.toArray()));
+
+        /* Проверка механизма расширения */
+        for (int i = 0; i < 10; i++) {
+            // При i = 5 длина списка превысит его вместимость, и в этот момент сработает механизм расширения
+            nums.add(i);
+        }
+        System.out.println("Список nums после увеличения вместимости = " + Arrays.toString(nums.toArray()) +
+                ", вместимость = " + nums.capacity() + " , длина = " + nums.size());
+    }
+}

ru/codes/java/chapter_backtracking/n_queens.java

@@ -0,0 +1,77 @@
+/**
+ * File: n_queens.java
+ * Created Time: 2023-05-04
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_backtracking;
+
+import java.util.*;
+
+public class n_queens {
+    /* Алгоритм бэктрекинга: n ферзей */
+    public static void backtrack(int row, int n, List<List<String>> state, List<List<List<String>>> res,
+            boolean[] cols, boolean[] diags1, boolean[] diags2) {
+        // Когда все строки уже обработаны, записать решение
+        if (row == n) {
+            List<List<String>> copyState = new ArrayList<>();
+            for (List<String> sRow : state) {
+                copyState.add(new ArrayList<>(sRow));
+            }
+            res.add(copyState);
+            return;
+        }
+        // Обойти все столбцы
+        for (int col = 0; col < n; col++) {
+            // Вычислить главную и побочную диагонали, соответствующие этой клетке
+            int diag1 = row - col + n - 1;
+            int diag2 = row + col;
+            // Отсечение: в столбце, главной диагонали и побочной диагонали этой клетки не должно быть ферзей
+            if (!cols[col] && !diags1[diag1] && !diags2[diag2]) {
+                // Попытка: поставить ферзя в эту клетку
+                state.get(row).set(col, "Q");
+                cols[col] = diags1[diag1] = diags2[diag2] = true;
+                // Перейти к размещению следующей строки
+                backtrack(row + 1, n, state, res, cols, diags1, diags2);
+                // Откат: восстановить эту клетку как пустую
+                state.get(row).set(col, "#");
+                cols[col] = diags1[diag1] = diags2[diag2] = false;
+            }
+        }
+    }
+
+    /* Решить задачу о n ферзях */
+    public static List<List<List<String>>> nQueens(int n) {
+        // Инициализировать доску размера n*n, где 'Q' обозначает ферзя, а '#' — пустую клетку
+        List<List<String>> state = new ArrayList<>();
+        for (int i = 0; i < n; i++) {
+            List<String> row = new ArrayList<>();
+            for (int j = 0; j < n; j++) {
+                row.add("#");
+            }
+            state.add(row);
+        }
+        boolean[] cols = new boolean[n]; // Отмечать, есть ли ферзь в столбце
+        boolean[] diags1 = new boolean[2 * n - 1]; // Отмечать наличие ферзя на главной диагонали
+        boolean[] diags2 = new boolean[2 * n - 1]; // Отмечать наличие ферзя на побочной диагонали
+        List<List<List<String>>> res = new ArrayList<>();
+
+        backtrack(0, n, state, res, cols, diags1, diags2);
+
+        return res;
+    }
+
+    public static void main(String[] args) {
+        int n = 4;
+        List<List<List<String>>> res = nQueens(n);
+
+        System.out.println("Размер входной доски = " + n);
+        System.out.println("Количество способов расстановки ферзей: " + res.size());
+        for (List<List<String>> state : res) {
+            System.out.println("--------------------");
+            for (List<String> row : state) {
+                System.out.println(row);
+            }
+        }
+    }
+}

ru/codes/java/chapter_backtracking/permutations_i.java

@@ -0,0 +1,51 @@
+/**
+ * File: permutations_i.java
+ * Created Time: 2023-04-24
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_backtracking;
+
+import java.util.*;
+
+public class permutations_i {
+    /* Алгоритм бэктрекинга: все перестановки I */
+    public static void backtrack(List<Integer> state, int[] choices, boolean[] selected, List<List<Integer>> res) {
+        // Когда длина состояния равна числу элементов, записать решение
+        if (state.size() == choices.length) {
+            res.add(new ArrayList<Integer>(state));
+            return;
+        }
+        // Перебор всех вариантов выбора
+        for (int i = 0; i < choices.length; i++) {
+            int choice = choices[i];
+            // Отсечение: нельзя выбирать один и тот же элемент повторно
+            if (!selected[i]) {
+                // Попытка: сделать выбор и обновить состояние
+                selected[i] = true;
+                state.add(choice);
+                // Перейти к следующему выбору
+                backtrack(state, choices, selected, res);
+                // Откат: отменить выбор и восстановить предыдущее состояние
+                selected[i] = false;
+                state.remove(state.size() - 1);
+            }
+        }
+    }
+
+    /* Все перестановки I */
+    static List<List<Integer>> permutationsI(int[] nums) {
+        List<List<Integer>> res = new ArrayList<List<Integer>>();
+        backtrack(new ArrayList<Integer>(), nums, new boolean[nums.length], res);
+        return res;
+    }
+
+    public static void main(String[] args) {
+        int[] nums = { 1, 2, 3 };
+
+        List<List<Integer>> res = permutationsI(nums);
+
+        System.out.println("Входной массив nums = " + Arrays.toString(nums));
+        System.out.println("Все перестановки res = " + res);
+    }
+}

ru/codes/java/chapter_backtracking/permutations_ii.java

@@ -0,0 +1,53 @@
+/**
+ * File: permutations_ii.java
+ * Created Time: 2023-04-24
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_backtracking;
+
+import java.util.*;
+
+public class permutations_ii {
+    /* Алгоритм бэктрекинга: все перестановки II */
+    static void backtrack(List<Integer> state, int[] choices, boolean[] selected, List<List<Integer>> res) {
+        // Когда длина состояния равна числу элементов, записать решение
+        if (state.size() == choices.length) {
+            res.add(new ArrayList<Integer>(state));
+            return;
+        }
+        // Перебор всех вариантов выбора
+        Set<Integer> duplicated = new HashSet<Integer>();
+        for (int i = 0; i < choices.length; i++) {
+            int choice = choices[i];
+            // Отсечение: нельзя выбирать один и тот же элемент повторно и нельзя повторно выбирать равные элементы
+            if (!selected[i] && !duplicated.contains(choice)) {
+                // Попытка: сделать выбор и обновить состояние
+                duplicated.add(choice); // Записать значения уже выбранных элементов
+                selected[i] = true;
+                state.add(choice);
+                // Перейти к следующему выбору
+                backtrack(state, choices, selected, res);
+                // Откат: отменить выбор и восстановить предыдущее состояние
+                selected[i] = false;
+                state.remove(state.size() - 1);
+            }
+        }
+    }
+
+    /* Все перестановки II */
+    static List<List<Integer>> permutationsII(int[] nums) {
+        List<List<Integer>> res = new ArrayList<List<Integer>>();
+        backtrack(new ArrayList<Integer>(), nums, new boolean[nums.length], res);
+        return res;
+    }
+
+    public static void main(String[] args) {
+        int[] nums = { 1, 2, 2 };
+
+        List<List<Integer>> res = permutationsII(nums);
+
+        System.out.println("Входной массив nums = " + Arrays.toString(nums));
+        System.out.println("Все перестановки res = " + res);
+    }
+}

ru/codes/java/chapter_backtracking/preorder_traversal_i_compact.java

@@ -0,0 +1,44 @@
+/**
+ * File: preorder_traversal_i_compact.java
+ * Created Time: 2023-04-16
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_backtracking;
+
+import utils.*;
+import java.util.*;
+
+public class preorder_traversal_i_compact {
+    static List<TreeNode> res;
+
+    /* Предварительный обход: пример 1 */
+    static void preOrder(TreeNode root) {
+        if (root == null) {
+            return;
+        }
+        if (root.val == 7) {
+            // Записать решение
+            res.add(root);
+        }
+        preOrder(root.left);
+        preOrder(root.right);
+    }
+
+    public static void main(String[] args) {
+        TreeNode root = TreeNode.listToTree(Arrays.asList(1, 7, 3, 4, 5, 6, 7));
+        System.out.println("\nИнициализация двоичного дерева");
+        PrintUtil.printTree(root);
+
+        // Предварительный обход
+        res = new ArrayList<>();
+        preOrder(root);
+
+        System.out.println("\nВсе узлы со значением 7");
+        List<Integer> vals = new ArrayList<>();
+        for (TreeNode node : res) {
+            vals.add(node.val);
+        }
+        System.out.println(vals);
+    }
+}

ru/codes/java/chapter_backtracking/preorder_traversal_ii_compact.java

@@ -0,0 +1,52 @@
+/**
+ * File: preorder_traversal_ii_compact.java
+ * Created Time: 2023-04-16
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_backtracking;
+
+import utils.*;
+import java.util.*;
+
+public class preorder_traversal_ii_compact {
+    static List<TreeNode> path;
+    static List<List<TreeNode>> res;
+
+    /* Предварительный обход: пример 2 */
+    static void preOrder(TreeNode root) {
+        if (root == null) {
+            return;
+        }
+        // Попытка
+        path.add(root);
+        if (root.val == 7) {
+            // Записать решение
+            res.add(new ArrayList<>(path));
+        }
+        preOrder(root.left);
+        preOrder(root.right);
+        // Откат
+        path.remove(path.size() - 1);
+    }
+
+    public static void main(String[] args) {
+        TreeNode root = TreeNode.listToTree(Arrays.asList(1, 7, 3, 4, 5, 6, 7));
+        System.out.println("\nИнициализация двоичного дерева");
+        PrintUtil.printTree(root);
+
+        // Предварительный обход
+        path = new ArrayList<>();
+        res = new ArrayList<>();
+        preOrder(root);
+
+        System.out.println("\nВсе пути от корня к узлу 7");
+        for (List<TreeNode> path : res) {
+            List<Integer> vals = new ArrayList<>();
+            for (TreeNode node : path) {
+                vals.add(node.val);
+            }
+            System.out.println(vals);
+        }
+    }
+}

ru/codes/java/chapter_backtracking/preorder_traversal_iii_compact.java

@@ -0,0 +1,53 @@
+/**
+ * File: preorder_traversal_iii_compact.java
+ * Created Time: 2023-04-16
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_backtracking;
+
+import utils.*;
+import java.util.*;
+
+public class preorder_traversal_iii_compact {
+    static List<TreeNode> path;
+    static List<List<TreeNode>> res;
+
+    /* Предварительный обход: пример 3 */
+    static void preOrder(TreeNode root) {
+        // Отсечение
+        if (root == null || root.val == 3) {
+            return;
+        }
+        // Попытка
+        path.add(root);
+        if (root.val == 7) {
+            // Записать решение
+            res.add(new ArrayList<>(path));
+        }
+        preOrder(root.left);
+        preOrder(root.right);
+        // Откат
+        path.remove(path.size() - 1);
+    }
+
+    public static void main(String[] args) {
+        TreeNode root = TreeNode.listToTree(Arrays.asList(1, 7, 3, 4, 5, 6, 7));
+        System.out.println("\nИнициализация двоичного дерева");
+        PrintUtil.printTree(root);
+
+        // Предварительный обход
+        path = new ArrayList<>();
+        res = new ArrayList<>();
+        preOrder(root);
+
+        System.out.println("\nВсе пути от корня к узлу 7, не содержащие узлов со значением 3");
+        for (List<TreeNode> path : res) {
+            List<Integer> vals = new ArrayList<>();
+            for (TreeNode node : path) {
+                vals.add(node.val);
+            }
+            System.out.println(vals);
+        }
+    }
+}

ru/codes/java/chapter_backtracking/preorder_traversal_iii_template.java

@@ -0,0 +1,77 @@
+/**
+ * File: preorder_traversal_iii_template.java
+ * Created Time: 2023-04-16
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_backtracking;
+
+import utils.*;
+import java.util.*;
+
+public class preorder_traversal_iii_template {
+    /* Проверить, является ли текущее состояние решением */
+    static boolean isSolution(List<TreeNode> state) {
+        return !state.isEmpty() && state.get(state.size() - 1).val == 7;
+    }
+
+    /* Записать решение */
+    static void recordSolution(List<TreeNode> state, List<List<TreeNode>> res) {
+        res.add(new ArrayList<>(state));
+    }
+
+    /* Проверить, допустим ли этот выбор в текущем состоянии */
+    static boolean isValid(List<TreeNode> state, TreeNode choice) {
+        return choice != null && choice.val != 3;
+    }
+
+    /* Обновить состояние */
+    static void makeChoice(List<TreeNode> state, TreeNode choice) {
+        state.add(choice);
+    }
+
+    /* Восстановить состояние */
+    static void undoChoice(List<TreeNode> state, TreeNode choice) {
+        state.remove(state.size() - 1);
+    }
+
+    /* Алгоритм бэктрекинга: пример 3 */
+    static void backtrack(List<TreeNode> state, List<TreeNode> choices, List<List<TreeNode>> res) {
+        // Проверить, является ли текущее состояние решением
+        if (isSolution(state)) {
+            // Записать решение
+            recordSolution(state, res);
+        }
+        // Перебор всех вариантов выбора
+        for (TreeNode choice : choices) {
+            // Отсечение: проверить допустимость выбора
+            if (isValid(state, choice)) {
+                // Попытка: сделать выбор и обновить состояние
+                makeChoice(state, choice);
+                // Перейти к следующему выбору
+                backtrack(state, Arrays.asList(choice.left, choice.right), res);
+                // Откат: отменить выбор и восстановить предыдущее состояние
+                undoChoice(state, choice);
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        TreeNode root = TreeNode.listToTree(Arrays.asList(1, 7, 3, 4, 5, 6, 7));
+        System.out.println("\nИнициализация двоичного дерева");
+        PrintUtil.printTree(root);
+
+        // Алгоритм бэктрекинга
+        List<List<TreeNode>> res = new ArrayList<>();
+        backtrack(new ArrayList<>(), Arrays.asList(root), res);
+
+        System.out.println("\nВсе пути от корня к узлу 7, в которых путь не содержит узлов со значением 3");
+        for (List<TreeNode> path : res) {
+            List<Integer> vals = new ArrayList<>();
+            for (TreeNode node : path) {
+                vals.add(node.val);
+            }
+            System.out.println(vals);
+        }
+    }
+}

ru/codes/java/chapter_backtracking/subset_sum_i.java

@@ -0,0 +1,55 @@
+/**
+ * File: subset_sum_i.java
+ * Created Time: 2023-06-21
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_backtracking;
+
+import java.util.*;
+
+public class subset_sum_i {
+    /* Алгоритм бэктрекинга: сумма подмножеств I */
+    static void backtrack(List<Integer> state, int target, int[] choices, int start, List<List<Integer>> res) {
+        // Если сумма подмножества равна target, записать решение
+        if (target == 0) {
+            res.add(new ArrayList<>(state));
+            return;
+        }
+        // Обойти все варианты выбора
+        // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств
+        for (int i = start; i < choices.length; i++) {
+            // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл
+            // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target
+            if (target - choices[i] < 0) {
+                break;
+            }
+            // Попытка: сделать выбор и обновить target и start
+            state.add(choices[i]);
+            // Перейти к следующему выбору
+            backtrack(state, target - choices[i], choices, i, res);
+            // Откат: отменить выбор и восстановить предыдущее состояние
+            state.remove(state.size() - 1);
+        }
+    }
+
+    /* Решить задачу суммы подмножеств I */
+    static List<List<Integer>> subsetSumI(int[] nums, int target) {
+        List<Integer> state = new ArrayList<>(); // Состояние (подмножество)
+        Arrays.sort(nums); // Отсортировать nums
+        int start = 0; // Стартовая вершина обхода
+        List<List<Integer>> res = new ArrayList<>(); // Список результатов (список подмножеств)
+        backtrack(state, target, nums, start, res);
+        return res;
+    }
+
+    public static void main(String[] args) {
+        int[] nums = { 3, 4, 5 };
+        int target = 9;
+
+        List<List<Integer>> res = subsetSumI(nums, target);
+
+        System.out.println("Входной массив nums = " + Arrays.toString(nums) + ", target = " + target);
+        System.out.println("Все подмножества с суммой " + target + ": res = " + res);
+    }
+}

ru/codes/java/chapter_backtracking/subset_sum_i_naive.java

@@ -0,0 +1,53 @@
+/**
+ * File: subset_sum_i_naive.java
+ * Created Time: 2023-06-21
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_backtracking;
+
+import java.util.*;
+
+public class subset_sum_i_naive {
+    /* Алгоритм бэктрекинга: сумма подмножеств I */
+    static void backtrack(List<Integer> state, int target, int total, int[] choices, List<List<Integer>> res) {
+        // Если сумма подмножества равна target, записать решение
+        if (total == target) {
+            res.add(new ArrayList<>(state));
+            return;
+        }
+        // Перебор всех вариантов выбора
+        for (int i = 0; i < choices.length; i++) {
+            // Отсечение: если сумма подмножества превышает target, пропустить этот выбор
+            if (total + choices[i] > target) {
+                continue;
+            }
+            // Попытка: сделать выбор и обновить элемент и total
+            state.add(choices[i]);
+            // Перейти к следующему выбору
+            backtrack(state, target, total + choices[i], choices, res);
+            // Откат: отменить выбор и восстановить предыдущее состояние
+            state.remove(state.size() - 1);
+        }
+    }
+
+    /* Решить задачу суммы подмножеств I (с повторяющимися подмножествами) */
+    static List<List<Integer>> subsetSumINaive(int[] nums, int target) {
+        List<Integer> state = new ArrayList<>(); // Состояние (подмножество)
+        int total = 0; // Сумма подмножеств
+        List<List<Integer>> res = new ArrayList<>(); // Список результатов (список подмножеств)
+        backtrack(state, target, total, nums, res);
+        return res;
+    }
+
+    public static void main(String[] args) {
+        int[] nums = { 3, 4, 5 };
+        int target = 9;
+
+        List<List<Integer>> res = subsetSumINaive(nums, target);
+
+        System.out.println("Входной массив nums = " + Arrays.toString(nums) + ", target = " + target);
+        System.out.println("Все подмножества с суммой " + target + ": res = " + res);
+        System.out.println("Обратите внимание: результат этого метода содержит повторяющиеся множества");
+    }
+}

ru/codes/java/chapter_backtracking/subset_sum_ii.java

@@ -0,0 +1,60 @@
+/**
+ * File: subset_sum_ii.java
+ * Created Time: 2023-06-21
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_backtracking;
+
+import java.util.*;
+
+public class subset_sum_ii {
+    /* Алгоритм бэктрекинга: сумма подмножеств II */
+    static void backtrack(List<Integer> state, int target, int[] choices, int start, List<List<Integer>> res) {
+        // Если сумма подмножества равна target, записать решение
+        if (target == 0) {
+            res.add(new ArrayList<>(state));
+            return;
+        }
+        // Обойти все варианты выбора
+        // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств
+        // Отсечение 3: начинать обход с start, чтобы избежать повторного выбора одного и того же элемента
+        for (int i = start; i < choices.length; i++) {
+            // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл
+            // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target
+            if (target - choices[i] < 0) {
+                break;
+            }
+            // Отсечение 4: если этот элемент равен элементу слева, значит ветвь поиска повторяется, ее нужно сразу пропустить
+            if (i > start && choices[i] == choices[i - 1]) {
+                continue;
+            }
+            // Попытка: сделать выбор и обновить target и start
+            state.add(choices[i]);
+            // Перейти к следующему выбору
+            backtrack(state, target - choices[i], choices, i + 1, res);
+            // Откат: отменить выбор и восстановить предыдущее состояние
+            state.remove(state.size() - 1);
+        }
+    }
+
+    /* Решить задачу суммы подмножеств II */
+    static List<List<Integer>> subsetSumII(int[] nums, int target) {
+        List<Integer> state = new ArrayList<>(); // Состояние (подмножество)
+        Arrays.sort(nums); // Отсортировать nums
+        int start = 0; // Стартовая вершина обхода
+        List<List<Integer>> res = new ArrayList<>(); // Список результатов (список подмножеств)
+        backtrack(state, target, nums, start, res);
+        return res;
+    }
+
+    public static void main(String[] args) {
+        int[] nums = { 4, 4, 5 };
+        int target = 9;
+
+        List<List<Integer>> res = subsetSumII(nums, target);
+
+        System.out.println("Входной массив nums = " + Arrays.toString(nums) + ", target = " + target);
+        System.out.println("Все подмножества с суммой " + target + ": res = " + res);
+    }
+}

ru/codes/java/chapter_computational_complexity/iteration.java

@@ -0,0 +1,76 @@
+/**
+ * File: iteration.java
+ * Created Time: 2023-08-24
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_computational_complexity;
+
+public class iteration {
+    /* Цикл for */
+    static int forLoop(int n) {
+        int res = 0;
+        // Циклическое суммирование 1, 2, ..., n-1, n
+        for (int i = 1; i <= n; i++) {
+            res += i;
+        }
+        return res;
+    }
+
+    /* Цикл while */
+    static int whileLoop(int n) {
+        int res = 0;
+        int i = 1; // Инициализация условной переменной
+        // Циклическое суммирование 1, 2, ..., n-1, n
+        while (i <= n) {
+            res += i;
+            i++; // Обновить условную переменную
+        }
+        return res;
+    }
+
+    /* Цикл while (двойное обновление) */
+    static int whileLoopII(int n) {
+        int res = 0;
+        int i = 1; // Инициализация условной переменной
+        // Циклическое суммирование 1, 4, 10, ...
+        while (i <= n) {
+            res += i;
+            // Обновить условную переменную
+            i++;
+            i *= 2;
+        }
+        return res;
+    }
+
+    /* Двойной цикл for */
+    static String nestedForLoop(int n) {
+        StringBuilder res = new StringBuilder();
+        // Цикл по i = 1, 2, ..., n-1, n
+        for (int i = 1; i <= n; i++) {
+            // Цикл по j = 1, 2, ..., n-1, n
+            for (int j = 1; j <= n; j++) {
+                res.append("(" + i + ", " + j + "), ");
+            }
+        }
+        return res.toString();
+    }
+
+    /* Driver Code */
+    public static void main(String[] args) {
+        int n = 5;
+        int res;
+
+        res = forLoop(n);
+        System.out.println("\nРезультат суммирования в цикле for res = " + res);
+
+        res = whileLoop(n);
+        System.out.println("\nРезультат суммирования в цикле while res = " + res);
+
+        res = whileLoopII(n);
+        System.out.println("\nРезультат суммирования в цикле while (двойное обновление) res = " + res);
+
+        String resStr = nestedForLoop(n);
+        System.out.println("\nРезультат обхода в двойном цикле for " + resStr);
+    }
+}

ru/codes/java/chapter_computational_complexity/recursion.java

@@ -0,0 +1,79 @@
+/**
+ * File: recursion.java
+ * Created Time: 2023-08-24
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_computational_complexity;
+
+import java.util.Stack;
+
+public class recursion {
+    /* Рекурсия */
+    static int recur(int n) {
+        // Условие завершения
+        if (n == 1)
+            return 1;
+        // Рекурсия: рекурсивный вызов
+        int res = recur(n - 1);
+        // Возврат: вернуть результат
+        return n + res;
+    }
+
+    /* Имитация рекурсии итерацией */
+    static int forLoopRecur(int n) {
+        // Использовать явный стек для имитации системного стека вызовов
+        Stack<Integer> stack = new Stack<>();
+        int res = 0;
+        // Рекурсия: рекурсивный вызов
+        for (int i = n; i > 0; i--) {
+            // Имитировать «рекурсию» с помощью операции помещения в стек
+            stack.push(i);
+        }
+        // Возврат: вернуть результат
+        while (!stack.isEmpty()) {
+            // Имитировать «возврат» с помощью операции извлечения из стека
+            res += stack.pop();
+        }
+        // res = 1+2+3+...+n
+        return res;
+    }
+
+    /* Хвостовая рекурсия */
+    static int tailRecur(int n, int res) {
+        // Условие завершения
+        if (n == 0)
+            return res;
+        // Хвостовой рекурсивный вызов
+        return tailRecur(n - 1, res + n);
+    }
+
+    /* Последовательность Фибоначчи: рекурсия */
+    static int fib(int n) {
+        // Условие завершения: f(1) = 0, f(2) = 1
+        if (n == 1 || n == 2)
+            return n - 1;
+        // Рекурсивный вызов f(n) = f(n-1) + f(n-2)
+        int res = fib(n - 1) + fib(n - 2);
+        // Вернуть результат f(n)
+        return res;
+    }
+
+    /* Driver Code */
+    public static void main(String[] args) {
+        int n = 5;
+        int res;
+
+        res = recur(n);
+        System.out.println("\nРезультат суммирования в рекурсивной функции res = " + res);
+
+        res = forLoopRecur(n);
+        System.out.println("\nРезультат суммирования при имитации рекурсии итерацией res = " + res);
+
+        res = tailRecur(n, 0);
+        System.out.println("\nРезультат суммирования в хвостовой рекурсии res = " + res);
+
+        res = fib(n);
+        System.out.println("\nЧлен последовательности Фибоначчи с номером " + n + " = " + res);
+    }
+}

ru/codes/java/chapter_computational_complexity/space_complexity.java

@@ -0,0 +1,110 @@
+/**
+ * File: space_complexity.java
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_computational_complexity;
+
+import utils.*;
+import java.util.*;
+
+public class space_complexity {
+    /* Функция */
+    static int function() {
+        // Выполнить некоторые операции
+        return 0;
+    }
+
+    /* Постоянная сложность */
+    static void constant(int n) {
+        // Константы, переменные и объекты занимают O(1) памяти
+        final int a = 0;
+        int b = 0;
+        int[] nums = new int[10000];
+        ListNode node = new ListNode(0);
+        // Переменные в цикле занимают O(1) памяти
+        for (int i = 0; i < n; i++) {
+            int c = 0;
+        }
+        // Функции в цикле занимают O(1) памяти
+        for (int i = 0; i < n; i++) {
+            function();
+        }
+    }
+
+    /* Линейная сложность */
+    static void linear(int n) {
+        // Массив длины n занимает O(n) памяти
+        int[] nums = new int[n];
+        // Список длины n занимает O(n) памяти
+        List<ListNode> nodes = new ArrayList<>();
+        for (int i = 0; i < n; i++) {
+            nodes.add(new ListNode(i));
+        }
+        // Хеш-таблица длины n занимает O(n) памяти
+        Map<Integer, String> map = new HashMap<>();
+        for (int i = 0; i < n; i++) {
+            map.put(i, String.valueOf(i));
+        }
+    }
+
+    /* Линейная сложность (рекурсивная реализация) */
+    static void linearRecur(int n) {
+        System.out.println("Рекурсия n = " + n);
+        if (n == 1)
+            return;
+        linearRecur(n - 1);
+    }
+
+    /* Квадратичная сложность */
+    static void quadratic(int n) {
+        // Матрица занимает O(n^2) памяти
+        int[][] numMatrix = new int[n][n];
+        // Двумерный список занимает O(n^2) памяти
+        List<List<Integer>> numList = new ArrayList<>();
+        for (int i = 0; i < n; i++) {
+            List<Integer> tmp = new ArrayList<>();
+            for (int j = 0; j < n; j++) {
+                tmp.add(0);
+            }
+            numList.add(tmp);
+        }
+    }
+
+    /* Квадратичная сложность (рекурсивная реализация) */
+    static int quadraticRecur(int n) {
+        if (n <= 0)
+            return 0;
+        // Длина массива nums равна n, n-1, ..., 2, 1
+        int[] nums = new int[n];
+        System.out.println("В рекурсии n = " + n + ", длина nums = " + nums.length);
+        return quadraticRecur(n - 1);
+    }
+
+    /* Экспоненциальная сложность (построение полного двоичного дерева) */
+    static TreeNode buildTree(int n) {
+        if (n == 0)
+            return null;
+        TreeNode root = new TreeNode(0);
+        root.left = buildTree(n - 1);
+        root.right = buildTree(n - 1);
+        return root;
+    }
+
+    /* Driver Code */
+    public static void main(String[] args) {
+        int n = 5;
+        // Постоянная сложность
+        constant(n);
+        // Линейная сложность
+        linear(n);
+        linearRecur(n);
+        // Квадратичная сложность
+        quadratic(n);
+        quadraticRecur(n);
+        // Экспоненциальная сложность
+        TreeNode root = buildTree(n);
+        PrintUtil.printTree(root);
+    }
+}

ru/codes/java/chapter_computational_complexity/time_complexity.java

@@ -0,0 +1,167 @@
+/**
+ * File: time_complexity.java
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_computational_complexity;
+
+public class time_complexity {
+    /* Постоянная сложность */
+    static int constant(int n) {
+        int count = 0;
+        int size = 100000;
+        for (int i = 0; i < size; i++)
+            count++;
+        return count;
+    }
+
+    /* Линейная сложность */
+    static int linear(int n) {
+        int count = 0;
+        for (int i = 0; i < n; i++)
+            count++;
+        return count;
+    }
+
+    /* Линейная сложность (обход массива) */
+    static int arrayTraversal(int[] nums) {
+        int count = 0;
+        // Число итераций пропорционально длине массива
+        for (int num : nums) {
+            count++;
+        }
+        return count;
+    }
+
+    /* Квадратичная сложность */
+    static int quadratic(int n) {
+        int count = 0;
+        // Число итераций квадратично зависит от размера данных n
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n; j++) {
+                count++;
+            }
+        }
+        return count;
+    }
+
+    /* Квадратичная сложность (пузырьковая сортировка) */
+    static int bubbleSort(int[] nums) {
+        int count = 0; // Счетчик
+        // Внешний цикл: неотсортированный диапазон [0, i]
+        for (int i = nums.length - 1; i > 0; i--) {
+            // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
+            for (int j = 0; j < i; j++) {
+                if (nums[j] > nums[j + 1]) {
+                    // Поменять местами nums[j] и nums[j + 1]
+                    int tmp = nums[j];
+                    nums[j] = nums[j + 1];
+                    nums[j + 1] = tmp;
+                    count += 3; // Обмен элементов включает 3 элементарные операции
+                }
+            }
+        }
+        return count;
+    }
+
+    /* Экспоненциальная сложность (итеративная реализация) */
+    static int exponential(int n) {
+        int count = 0, base = 1;
+        // На каждом шаге клетка делится надвое, образуя последовательность 1, 2, 4, 8, ..., 2^(n-1)
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < base; j++) {
+                count++;
+            }
+            base *= 2;
+        }
+        // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
+        return count;
+    }
+
+    /* Экспоненциальная сложность (рекурсивная реализация) */
+    static int expRecur(int n) {
+        if (n == 1)
+            return 1;
+        return expRecur(n - 1) + expRecur(n - 1) + 1;
+    }
+
+    /* Логарифмическая сложность (итеративная реализация) */
+    static int logarithmic(int n) {
+        int count = 0;
+        while (n > 1) {
+            n = n / 2;
+            count++;
+        }
+        return count;
+    }
+
+    /* Логарифмическая сложность (рекурсивная реализация) */
+    static int logRecur(int n) {
+        if (n <= 1)
+            return 0;
+        return logRecur(n / 2) + 1;
+    }
+
+    /* Линейно-логарифмическая сложность */
+    static int linearLogRecur(int n) {
+        if (n <= 1)
+            return 1;
+        int count = linearLogRecur(n / 2) + linearLogRecur(n / 2);
+        for (int i = 0; i < n; i++) {
+            count++;
+        }
+        return count;
+    }
+
+    /* Факториальная сложность (рекурсивная реализация) */
+    static int factorialRecur(int n) {
+        if (n == 0)
+            return 1;
+        int count = 0;
+        // Из одного получается n
+        for (int i = 0; i < n; i++) {
+            count += factorialRecur(n - 1);
+        }
+        return count;
+    }
+
+    /* Driver Code */
+    public static void main(String[] args) {
+        // Можно изменить n и запустить программу, чтобы увидеть, как меняется число операций при разных сложностях
+        int n = 8;
+        System.out.println("Размер входных данных n = " + n);
+
+        int count = constant(n);
+        System.out.println("Число операций константной сложности = " + count);
+
+        count = linear(n);
+        System.out.println("Число операций линейной сложности = " + count);
+        count = arrayTraversal(new int[n]);
+        System.out.println("Число операций линейной сложности (обход массива) = " + count);
+
+        count = quadratic(n);
+        System.out.println("Число операций квадратичной сложности = " + count);
+        int[] nums = new int[n];
+        for (int i = 0; i < n; i++)
+            nums[i] = n - i; // [n,n-1,...,2,1]
+        count = bubbleSort(nums);
+        System.out.println("Число операций квадратичной сложности (пузырьковая сортировка) = " + count);
+
+        count = exponential(n);
+        System.out.println("Число операций экспоненциальной сложности (итеративная реализация) = " + count);
+        count = expRecur(n);
+        System.out.println("Число операций экспоненциальной сложности (рекурсивная реализация) = " + count);
+
+        count = logarithmic(n);
+        System.out.println("Число операций логарифмической сложности (итеративная реализация) = " + count);
+        count = logRecur(n);
+        System.out.println("Число операций логарифмической сложности (рекурсивная реализация) = " + count);
+
+        count = linearLogRecur(n);
+        System.out.println("Число операций линейно-логарифмической сложности (рекурсивная реализация) = " + count);
+
+        count = factorialRecur(n);
+        System.out.println("Число операций факториальной сложности (рекурсивная реализация) = " + count);
+    }
+}

ru/codes/java/chapter_computational_complexity/worst_best_time_complexity.java

@@ -0,0 +1,50 @@
+/**
+ * File: worst_best_time_complexity.java
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_computational_complexity;
+
+import java.util.*;
+
+public class worst_best_time_complexity {
+    /* Создать массив с элементами { 1, 2, ..., n } в случайном порядке */
+    static int[] randomNumbers(int n) {
+        Integer[] nums = new Integer[n];
+        // Создать массив nums = { 1, 2, 3, ..., n }
+        for (int i = 0; i < n; i++) {
+            nums[i] = i + 1;
+        }
+        // Случайно перемешать элементы массива
+        Collections.shuffle(Arrays.asList(nums));
+        // Integer[] -> int[]
+        int[] res = new int[n];
+        for (int i = 0; i < n; i++) {
+            res[i] = nums[i];
+        }
+        return res;
+    }
+
+    /* Найти индекс числа 1 в массиве nums */
+    static int findOne(int[] nums) {
+        for (int i = 0; i < nums.length; i++) {
+            // Когда элемент 1 находится в начале массива, достигается лучшая временная сложность O(1)
+            // Когда элемент 1 находится в конце массива, достигается худшая временная сложность O(n)
+            if (nums[i] == 1)
+                return i;
+        }
+        return -1;
+    }
+
+    /* Driver Code */
+    public static void main(String[] args) {
+        for (int i = 0; i < 10; i++) {
+            int n = 100;
+            int[] nums = randomNumbers(n);
+            int index = findOne(nums);
+            System.out.println("\nМассив [1, 2, ..., n] после перемешивания = " + Arrays.toString(nums));
+            System.out.println("Индекс числа 1 = " + index);
+        }
+    }
+}

ru/codes/java/chapter_divide_and_conquer/binary_search_recur.java

@@ -0,0 +1,45 @@
+/**
+ * File: binary_search_recur.java
+ * Created Time: 2023-07-17
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_divide_and_conquer;
+
+public class binary_search_recur {
+    /* Бинарный поиск: задача f(i, j) */
+    static int dfs(int[] nums, int target, int i, int j) {
+        // Если интервал пуст, целевой элемент отсутствует, вернуть -1
+        if (i > j) {
+            return -1;
+        }
+        // Вычислить индекс середины m
+        int m = (i + j) / 2;
+        if (nums[m] < target) {
+            // Рекурсивная подзадача f(m+1, j)
+            return dfs(nums, target, m + 1, j);
+        } else if (nums[m] > target) {
+            // Рекурсивная подзадача f(i, m-1)
+            return dfs(nums, target, i, m - 1);
+        } else {
+            // Целевой элемент найден, вернуть его индекс
+            return m;
+        }
+    }
+
+    /* Бинарный поиск */
+    static int binarySearch(int[] nums, int target) {
+        int n = nums.length;
+        // Решить задачу f(0, n-1)
+        return dfs(nums, target, 0, n - 1);
+    }
+
+    public static void main(String[] args) {
+        int target = 6;
+        int[] nums = { 1, 3, 6, 8, 12, 15, 23, 26, 31, 35 };
+
+        // Бинарный поиск (двусторонне замкнутый интервал)
+        int index = binarySearch(nums, target);
+        System.out.println("Индекс целевого элемента 6 = " + index);
+    }
+}

ru/codes/java/chapter_divide_and_conquer/build_tree.java

@@ -0,0 +1,51 @@
+/**
+ * File: build_tree.java
+ * Created Time: 2023-07-17
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_divide_and_conquer;
+
+import utils.*;
+import java.util.*;
+
+public class build_tree {
+    /* Построить двоичное дерево: разделяй и властвуй */
+    static TreeNode dfs(int[] preorder, Map<Integer, Integer> inorderMap, int i, int l, int r) {
+        // Завершить при пустом диапазоне поддерева
+        if (r - l < 0)
+            return null;
+        // Инициализировать корневой узел
+        TreeNode root = new TreeNode(preorder[i]);
+        // Найти m, чтобы разделить левое и правое поддеревья
+        int m = inorderMap.get(preorder[i]);
+        // Подзадача: построить левое поддерево
+        root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);
+        // Подзадача: построить правое поддерево
+        root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);
+        // Вернуть корневой узел
+        return root;
+    }
+
+    /* Построить двоичное дерево */
+    static TreeNode buildTree(int[] preorder, int[] inorder) {
+        // Инициализировать хеш-таблицу для хранения соответствия элементов inorder их индексам
+        Map<Integer, Integer> inorderMap = new HashMap<>();
+        for (int i = 0; i < inorder.length; i++) {
+            inorderMap.put(inorder[i], i);
+        }
+        TreeNode root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);
+        return root;
+    }
+
+    public static void main(String[] args) {
+        int[] preorder = { 3, 9, 2, 1, 7 };
+        int[] inorder = { 9, 3, 1, 2, 7 };
+        System.out.println("Предварительный обход = " + Arrays.toString(preorder));
+        System.out.println("Симметричный обход = " + Arrays.toString(inorder));
+
+        TreeNode root = buildTree(preorder, inorder);
+        System.out.println("Построенное двоичное дерево:");
+        PrintUtil.printTree(root);
+    }
+}

ru/codes/java/chapter_divide_and_conquer/hanota.java

@@ -0,0 +1,59 @@
+/**
+ * File: hanota.java
+ * Created Time: 2023-07-17
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_divide_and_conquer;
+
+import java.util.*;
+
+public class hanota {
+    /* Переместить один диск */
+    static void move(List<Integer> src, List<Integer> tar) {
+        // Снять диск с вершины src
+        Integer pan = src.remove(src.size() - 1);
+        // Положить диск на вершину tar
+        tar.add(pan);
+    }
+
+    /* Решить задачу Ханойской башни f(i) */
+    static void dfs(int i, List<Integer> src, List<Integer> buf, List<Integer> tar) {
+        // Если в src остался только один диск, сразу переместить его в tar
+        if (i == 1) {
+            move(src, tar);
+            return;
+        }
+        // Подзадача f(i-1): переместить верхние i-1 дисков из src в buf с помощью tar
+        dfs(i - 1, src, tar, buf);
+        // Подзадача f(1): переместить оставшийся один диск из src в tar
+        move(src, tar);
+        // Подзадача f(i-1): переместить верхние i-1 дисков из buf в tar с помощью src
+        dfs(i - 1, buf, src, tar);
+    }
+
+    /* Решить задачу Ханойской башни */
+    static void solveHanota(List<Integer> A, List<Integer> B, List<Integer> C) {
+        int n = A.size();
+        // Переместить верхние n дисков из A в C с помощью B
+        dfs(n, A, B, C);
+    }
+
+    public static void main(String[] args) {
+        // Хвост списка соответствует вершине столбца
+        List<Integer> A = new ArrayList<>(Arrays.asList(5, 4, 3, 2, 1));
+        List<Integer> B = new ArrayList<>();
+        List<Integer> C = new ArrayList<>();
+        System.out.println("Исходное состояние:");
+        System.out.println("A = " + A);
+        System.out.println("B = " + B);
+        System.out.println("C = " + C);
+
+        solveHanota(A, B, C);
+
+        System.out.println("После завершения перемещения дисков:");
+        System.out.println("A = " + A);
+        System.out.println("B = " + B);
+        System.out.println("C = " + C);
+    }
+}

ru/codes/java/chapter_dynamic_programming/climbing_stairs_backtrack.java

@@ -0,0 +1,44 @@
+/**
+ * File: climbing_stairs_backtrack.java
+ * Created Time: 2023-06-30
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_dynamic_programming;
+
+import java.util.*;
+
+public class climbing_stairs_backtrack {
+    /* Бэктрекинг */
+    public static void backtrack(List<Integer> choices, int state, int n, List<Integer> res) {
+        // Когда подъем достигает n-й ступени, число вариантов увеличивается на 1
+        if (state == n)
+            res.set(0, res.get(0) + 1);
+        // Перебор всех вариантов выбора
+        for (Integer choice : choices) {
+            // Отсечение: нельзя выходить за n-ю ступень
+            if (state + choice > n)
+                continue;
+            // Попытка: сделать выбор и обновить состояние
+            backtrack(choices, state + choice, n, res);
+            // Откат
+        }
+    }
+
+    /* Подъем по лестнице: бэктрекинг */
+    public static int climbingStairsBacktrack(int n) {
+        List<Integer> choices = Arrays.asList(1, 2); // Можно подняться на 1 или 2 ступени
+        int state = 0; // Начать подъем с 0-й ступени
+        List<Integer> res = new ArrayList<>();
+        res.add(0); // Использовать res[0] для хранения числа решений
+        backtrack(choices, state, n, res);
+        return res.get(0);
+    }
+
+    public static void main(String[] args) {
+        int n = 9;
+
+        int res = climbingStairsBacktrack(n);
+        System.out.println(String.format("Количество способов подняться по лестнице из %d ступеней: %d", n, res));
+    }
+}

ru/codes/java/chapter_dynamic_programming/climbing_stairs_constraint_dp.java

@@ -0,0 +1,36 @@
+/**
+ * File: climbing_stairs_constraint_dp.java
+ * Created Time: 2023-07-01
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_dynamic_programming;
+
+public class climbing_stairs_constraint_dp {
+    /* Подъем по лестнице с ограничениями: динамическое программирование */
+    static int climbingStairsConstraintDP(int n) {
+        if (n == 1 || n == 2) {
+            return 1;
+        }
+        // Инициализация таблицы dp для хранения решений подзадач
+        int[][] dp = new int[n + 1][3];
+        // Начальное состояние: заранее задать решения наименьших подзадач
+        dp[1][1] = 1;
+        dp[1][2] = 0;
+        dp[2][1] = 0;
+        dp[2][2] = 1;
+        // Переход состояний: постепенное решение больших подзадач через меньшие
+        for (int i = 3; i <= n; i++) {
+            dp[i][1] = dp[i - 1][2];
+            dp[i][2] = dp[i - 2][1] + dp[i - 2][2];
+        }
+        return dp[n][1] + dp[n][2];
+    }
+
+    public static void main(String[] args) {
+        int n = 9;
+
+        int res = climbingStairsConstraintDP(n);
+        System.out.println(String.format("Количество способов подняться по лестнице из %d ступеней: %d", n, res));
+    }
+}

ru/codes/java/chapter_dynamic_programming/climbing_stairs_dfs.java

@@ -0,0 +1,31 @@
+/**
+ * File: climbing_stairs_dfs.java
+ * Created Time: 2023-06-30
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_dynamic_programming;
+
+public class climbing_stairs_dfs {
+    /* Поиск */
+    public static int dfs(int i) {
+        // dp[1] и dp[2] уже известны, вернуть их
+        if (i == 1 || i == 2)
+            return i;
+        // dp[i] = dp[i-1] + dp[i-2]
+        int count = dfs(i - 1) + dfs(i - 2);
+        return count;
+    }
+
+    /* Подъем по лестнице: поиск */
+    public static int climbingStairsDFS(int n) {
+        return dfs(n);
+    }
+
+    public static void main(String[] args) {
+        int n = 9;
+
+        int res = climbingStairsDFS(n);
+        System.out.println(String.format("Количество способов подняться по лестнице из %d ступеней: %d", n, res));
+    }
+}

ru/codes/java/chapter_dynamic_programming/climbing_stairs_dfs_mem.java

@@ -0,0 +1,41 @@
+/**
+ * File: climbing_stairs_dfs_mem.java
+ * Created Time: 2023-06-30
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_dynamic_programming;
+
+import java.util.Arrays;
+
+public class climbing_stairs_dfs_mem {
+    /* Поиск с мемоизацией */
+    public static int dfs(int i, int[] mem) {
+        // dp[1] и dp[2] уже известны, вернуть их
+        if (i == 1 || i == 2)
+            return i;
+        // Если запись dp[i] существует, сразу вернуть ее
+        if (mem[i] != -1)
+            return mem[i];
+        // dp[i] = dp[i-1] + dp[i-2]
+        int count = dfs(i - 1, mem) + dfs(i - 2, mem);
+        // Сохранить dp[i]
+        mem[i] = count;
+        return count;
+    }
+
+    /* Подъем по лестнице: поиск с мемоизацией */
+    public static int climbingStairsDFSMem(int n) {
+        // mem[i] хранит число способов подняться на i-ю ступень, -1 означает отсутствие записи
+        int[] mem = new int[n + 1];
+        Arrays.fill(mem, -1);
+        return dfs(n, mem);
+    }
+
+    public static void main(String[] args) {
+        int n = 9;
+
+        int res = climbingStairsDFSMem(n);
+        System.out.println(String.format("Количество способов подняться по лестнице из %d ступеней: %d", n, res));
+    }
+}

ru/codes/java/chapter_dynamic_programming/climbing_stairs_dp.java

@@ -0,0 +1,48 @@
+/**
+ * File: climbing_stairs_dp.java
+ * Created Time: 2023-06-30
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_dynamic_programming;
+
+public class climbing_stairs_dp {
+    /* Подъем по лестнице: динамическое программирование */
+    public static int climbingStairsDP(int n) {
+        if (n == 1 || n == 2)
+            return n;
+        // Инициализация таблицы dp для хранения решений подзадач
+        int[] dp = new int[n + 1];
+        // Начальное состояние: заранее задать решения наименьших подзадач
+        dp[1] = 1;
+        dp[2] = 2;
+        // Переход состояний: постепенное решение больших подзадач через меньшие
+        for (int i = 3; i <= n; i++) {
+            dp[i] = dp[i - 1] + dp[i - 2];
+        }
+        return dp[n];
+    }
+
+    /* Подъем по лестнице: динамическое программирование с оптимизацией памяти */
+    public static int climbingStairsDPComp(int n) {
+        if (n == 1 || n == 2)
+            return n;
+        int a = 1, b = 2;
+        for (int i = 3; i <= n; i++) {
+            int tmp = b;
+            b = a + b;
+            a = tmp;
+        }
+        return b;
+    }
+
+    public static void main(String[] args) {
+        int n = 9;
+
+        int res = climbingStairsDP(n);
+        System.out.println(String.format("Количество способов подняться по лестнице из %d ступеней: %d", n, res));
+
+        res = climbingStairsDPComp(n);
+        System.out.println(String.format("Количество способов подняться по лестнице из %d ступеней: %d", n, res));
+    }
+}

ru/codes/java/chapter_dynamic_programming/coin_change.java

@@ -0,0 +1,72 @@
+/**
+ * File: coin_change.java
+ * Created Time: 2023-07-11
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_dynamic_programming;
+
+import java.util.Arrays;
+
+public class coin_change {
+    /* Размен монет: динамическое программирование */
+    static int coinChangeDP(int[] coins, int amt) {
+        int n = coins.length;
+        int MAX = amt + 1;
+        // Инициализация таблицы dp
+        int[][] dp = new int[n + 1][amt + 1];
+        // Переход состояний: первая строка и первый столбец
+        for (int a = 1; a <= amt; a++) {
+            dp[0][a] = MAX;
+        }
+        // Переход состояний: остальные строки и столбцы
+        for (int i = 1; i <= n; i++) {
+            for (int a = 1; a <= amt; a++) {
+                if (coins[i - 1] > a) {
+                    // Если целевая сумма превышена, монету i не выбирать
+                    dp[i][a] = dp[i - 1][a];
+                } else {
+                    // Меньшее из двух решений: не брать или взять монету i
+                    dp[i][a] = Math.min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);
+                }
+            }
+        }
+        return dp[n][amt] != MAX ? dp[n][amt] : -1;
+    }
+
+    /* Размен монет: динамическое программирование с оптимизацией памяти */
+    static int coinChangeDPComp(int[] coins, int amt) {
+        int n = coins.length;
+        int MAX = amt + 1;
+        // Инициализация таблицы dp
+        int[] dp = new int[amt + 1];
+        Arrays.fill(dp, MAX);
+        dp[0] = 0;
+        // Переход состояний
+        for (int i = 1; i <= n; i++) {
+            for (int a = 1; a <= amt; a++) {
+                if (coins[i - 1] > a) {
+                    // Если целевая сумма превышена, монету i не выбирать
+                    dp[a] = dp[a];
+                } else {
+                    // Меньшее из двух решений: не брать или взять монету i
+                    dp[a] = Math.min(dp[a], dp[a - coins[i - 1]] + 1);
+                }
+            }
+        }
+        return dp[amt] != MAX ? dp[amt] : -1;
+    }
+
+    public static void main(String[] args) {
+        int[] coins = { 1, 2, 5 };
+        int amt = 4;
+
+        // Динамическое программирование
+        int res = coinChangeDP(coins, amt);
+        System.out.println("Минимальное число монет для набора целевой суммы = " + res);
+
+        // Динамическое программирование с оптимизацией памяти
+        res = coinChangeDPComp(coins, amt);
+        System.out.println("Минимальное число монет для набора целевой суммы = " + res);
+    }
+}

ru/codes/java/chapter_dynamic_programming/coin_change_ii.java

@@ -0,0 +1,67 @@
+/**
+ * File: coin_change_ii.java
+ * Created Time: 2023-07-11
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_dynamic_programming;
+
+public class coin_change_ii {
+    /* Размен монет II: динамическое программирование */
+    static int coinChangeIIDP(int[] coins, int amt) {
+        int n = coins.length;
+        // Инициализация таблицы dp
+        int[][] dp = new int[n + 1][amt + 1];
+        // Инициализация первого столбца
+        for (int i = 0; i <= n; i++) {
+            dp[i][0] = 1;
+        }
+        // Переход состояний
+        for (int i = 1; i <= n; i++) {
+            for (int a = 1; a <= amt; a++) {
+                if (coins[i - 1] > a) {
+                    // Если целевая сумма превышена, монету i не выбирать
+                    dp[i][a] = dp[i - 1][a];
+                } else {
+                    // Сумма двух решений: не брать или взять монету i
+                    dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];
+                }
+            }
+        }
+        return dp[n][amt];
+    }
+
+    /* Размен монет II: динамическое программирование с оптимизацией памяти */
+    static int coinChangeIIDPComp(int[] coins, int amt) {
+        int n = coins.length;
+        // Инициализация таблицы dp
+        int[] dp = new int[amt + 1];
+        dp[0] = 1;
+        // Переход состояний
+        for (int i = 1; i <= n; i++) {
+            for (int a = 1; a <= amt; a++) {
+                if (coins[i - 1] > a) {
+                    // Если целевая сумма превышена, монету i не выбирать
+                    dp[a] = dp[a];
+                } else {
+                    // Сумма двух решений: не брать или взять монету i
+                    dp[a] = dp[a] + dp[a - coins[i - 1]];
+                }
+            }
+        }
+        return dp[amt];
+    }
+
+    public static void main(String[] args) {
+        int[] coins = { 1, 2, 5 };
+        int amt = 5;
+
+        // Динамическое программирование
+        int res = coinChangeIIDP(coins, amt);
+        System.out.println("Количество комбинаций монет для набора целевой суммы = " + res);
+
+        // Динамическое программирование с оптимизацией памяти
+        res = coinChangeIIDPComp(coins, amt);
+        System.out.println("Количество комбинаций монет для набора целевой суммы = " + res);
+    }
+}

ru/codes/java/chapter_dynamic_programming/edit_distance.java

@@ -0,0 +1,139 @@
+/**
+ * File: edit_distance.java
+ * Created Time: 2023-07-13
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_dynamic_programming;
+
+import java.util.Arrays;
+
+public class edit_distance {
+    /* Редакционное расстояние: полный перебор */
+    static int editDistanceDFS(String s, String t, int i, int j) {
+        // Если s и t пусты, вернуть 0
+        if (i == 0 && j == 0)
+            return 0;
+        // Если s пусто, вернуть длину t
+        if (i == 0)
+            return j;
+        // Если t пусто, вернуть длину s
+        if (j == 0)
+            return i;
+        // Если два символа равны, сразу пропустить их
+        if (s.charAt(i - 1) == t.charAt(j - 1))
+            return editDistanceDFS(s, t, i - 1, j - 1);
+        // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1
+        int insert = editDistanceDFS(s, t, i, j - 1);
+        int delete = editDistanceDFS(s, t, i - 1, j);
+        int replace = editDistanceDFS(s, t, i - 1, j - 1);
+        // Вернуть минимальное число шагов редактирования
+        return Math.min(Math.min(insert, delete), replace) + 1;
+    }
+
+    /* Редакционное расстояние: поиск с мемоизацией */
+    static int editDistanceDFSMem(String s, String t, int[][] mem, int i, int j) {
+        // Если s и t пусты, вернуть 0
+        if (i == 0 && j == 0)
+            return 0;
+        // Если s пусто, вернуть длину t
+        if (i == 0)
+            return j;
+        // Если t пусто, вернуть длину s
+        if (j == 0)
+            return i;
+        // Если запись уже есть, сразу вернуть ее
+        if (mem[i][j] != -1)
+            return mem[i][j];
+        // Если два символа равны, сразу пропустить их
+        if (s.charAt(i - 1) == t.charAt(j - 1))
+            return editDistanceDFSMem(s, t, mem, i - 1, j - 1);
+        // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1
+        int insert = editDistanceDFSMem(s, t, mem, i, j - 1);
+        int delete = editDistanceDFSMem(s, t, mem, i - 1, j);
+        int replace = editDistanceDFSMem(s, t, mem, i - 1, j - 1);
+        // Сохранить и вернуть минимальное число шагов редактирования
+        mem[i][j] = Math.min(Math.min(insert, delete), replace) + 1;
+        return mem[i][j];
+    }
+
+    /* Редакционное расстояние: динамическое программирование */
+    static int editDistanceDP(String s, String t) {
+        int n = s.length(), m = t.length();
+        int[][] dp = new int[n + 1][m + 1];
+        // Переход состояний: первая строка и первый столбец
+        for (int i = 1; i <= n; i++) {
+            dp[i][0] = i;
+        }
+        for (int j = 1; j <= m; j++) {
+            dp[0][j] = j;
+        }
+        // Переход состояний: остальные строки и столбцы
+        for (int i = 1; i <= n; i++) {
+            for (int j = 1; j <= m; j++) {
+                if (s.charAt(i - 1) == t.charAt(j - 1)) {
+                    // Если два символа равны, сразу пропустить их
+                    dp[i][j] = dp[i - 1][j - 1];
+                } else {
+                    // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1
+                    dp[i][j] = Math.min(Math.min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;
+                }
+            }
+        }
+        return dp[n][m];
+    }
+
+    /* Редакционное расстояние: динамическое программирование с оптимизацией памяти */
+    static int editDistanceDPComp(String s, String t) {
+        int n = s.length(), m = t.length();
+        int[] dp = new int[m + 1];
+        // Переход состояний: первая строка
+        for (int j = 1; j <= m; j++) {
+            dp[j] = j;
+        }
+        // Переход состояний: остальные строки
+        for (int i = 1; i <= n; i++) {
+            // Переход состояний: первый столбец
+            int leftup = dp[0]; // Временно сохранить dp[i-1, j-1]
+            dp[0] = i;
+            // Переход состояний: остальные столбцы
+            for (int j = 1; j <= m; j++) {
+                int temp = dp[j];
+                if (s.charAt(i - 1) == t.charAt(j - 1)) {
+                    // Если два символа равны, сразу пропустить их
+                    dp[j] = leftup;
+                } else {
+                    // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1
+                    dp[j] = Math.min(Math.min(dp[j - 1], dp[j]), leftup) + 1;
+                }
+                leftup = temp; // Обновить до значения dp[i-1, j-1] для следующей итерации
+            }
+        }
+        return dp[m];
+    }
+
+    public static void main(String[] args) {
+        String s = "bag";
+        String t = "pack";
+        int n = s.length(), m = t.length();
+
+        // Полный перебор
+        int res = editDistanceDFS(s, t, n, m);
+        System.out.println("Чтобы преобразовать " + s + " в " + t + ", нужно минимум " + res + " шагов");
+
+        // Поиск с мемоизацией
+        int[][] mem = new int[n + 1][m + 1];
+        for (int[] row : mem)
+            Arrays.fill(row, -1);
+        res = editDistanceDFSMem(s, t, mem, n, m);
+        System.out.println("Чтобы преобразовать " + s + " в " + t + ", нужно минимум " + res + " шагов");
+
+        // Динамическое программирование
+        res = editDistanceDP(s, t);
+        System.out.println("Чтобы преобразовать " + s + " в " + t + ", нужно минимум " + res + " шагов");
+
+        // Динамическое программирование с оптимизацией памяти
+        res = editDistanceDPComp(s, t);
+        System.out.println("Чтобы преобразовать " + s + " в " + t + ", нужно минимум " + res + " шагов");
+    }
+}

ru/codes/java/chapter_dynamic_programming/knapsack.java

@@ -0,0 +1,116 @@
+/**
+ * File: knapsack.java
+ * Created Time: 2023-07-10
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_dynamic_programming;
+
+import java.util.Arrays;
+
+public class knapsack {
+
+    /* Рюкзак 0-1: полный перебор */
+    static int knapsackDFS(int[] wgt, int[] val, int i, int c) {
+        // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0
+        if (i == 0 || c == 0) {
+            return 0;
+        }
+        // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак
+        if (wgt[i - 1] > c) {
+            return knapsackDFS(wgt, val, i - 1, c);
+        }
+        // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут
+        int no = knapsackDFS(wgt, val, i - 1, c);
+        int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];
+        // Вернуть вариант с большей стоимостью из двух возможных
+        return Math.max(no, yes);
+    }
+
+    /* Рюкзак 0-1: поиск с мемоизацией */
+    static int knapsackDFSMem(int[] wgt, int[] val, int[][] mem, int i, int c) {
+        // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0
+        if (i == 0 || c == 0) {
+            return 0;
+        }
+        // Если запись уже есть, вернуть сразу
+        if (mem[i][c] != -1) {
+            return mem[i][c];
+        }
+        // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак
+        if (wgt[i - 1] > c) {
+            return knapsackDFSMem(wgt, val, mem, i - 1, c);
+        }
+        // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут
+        int no = knapsackDFSMem(wgt, val, mem, i - 1, c);
+        int yes = knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];
+        // Сохранить и вернуть вариант с большей стоимостью из двух решений
+        mem[i][c] = Math.max(no, yes);
+        return mem[i][c];
+    }
+
+    /* Рюкзак 0-1: динамическое программирование */
+    static int knapsackDP(int[] wgt, int[] val, int cap) {
+        int n = wgt.length;
+        // Инициализация таблицы dp
+        int[][] dp = new int[n + 1][cap + 1];
+        // Переход состояний
+        for (int i = 1; i <= n; i++) {
+            for (int c = 1; c <= cap; c++) {
+                if (wgt[i - 1] > c) {
+                    // Если вместимость рюкзака превышена, предмет i не выбирать
+                    dp[i][c] = dp[i - 1][c];
+                } else {
+                    // Большее из двух решений: не брать или взять предмет i
+                    dp[i][c] = Math.max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);
+                }
+            }
+        }
+        return dp[n][cap];
+    }
+
+    /* Рюкзак 0-1: динамическое программирование с оптимизацией памяти */
+    static int knapsackDPComp(int[] wgt, int[] val, int cap) {
+        int n = wgt.length;
+        // Инициализация таблицы dp
+        int[] dp = new int[cap + 1];
+        // Переход состояний
+        for (int i = 1; i <= n; i++) {
+            // Обход в обратном порядке
+            for (int c = cap; c >= 1; c--) {
+                if (wgt[i - 1] <= c) {
+                    // Большее из двух решений: не брать или взять предмет i
+                    dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);
+                }
+            }
+        }
+        return dp[cap];
+    }
+
+    public static void main(String[] args) {
+        int[] wgt = { 10, 20, 30, 40, 50 };
+        int[] val = { 50, 120, 150, 210, 240 };
+        int cap = 50;
+        int n = wgt.length;
+
+        // Полный перебор
+        int res = knapsackDFS(wgt, val, n, cap);
+        System.out.println("Максимальная стоимость предметов без превышения вместимости рюкзака = " + res);
+
+        // Поиск с мемоизацией
+        int[][] mem = new int[n + 1][cap + 1];
+        for (int[] row : mem) {
+            Arrays.fill(row, -1);
+        }
+        res = knapsackDFSMem(wgt, val, mem, n, cap);
+        System.out.println("Максимальная стоимость предметов без превышения вместимости рюкзака = " + res);
+
+        // Динамическое программирование
+        res = knapsackDP(wgt, val, cap);
+        System.out.println("Максимальная стоимость предметов без превышения вместимости рюкзака = " + res);
+
+        // Динамическое программирование с оптимизацией памяти
+        res = knapsackDPComp(wgt, val, cap);
+        System.out.println("Максимальная стоимость предметов без превышения вместимости рюкзака = " + res);
+    }
+}

ru/codes/java/chapter_dynamic_programming/min_cost_climbing_stairs_dp.java

@@ -0,0 +1,53 @@
+/**
+ * File: min_cost_climbing_stairs_dp.java
+ * Created Time: 2023-06-30
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_dynamic_programming;
+
+import java.util.Arrays;
+
+public class min_cost_climbing_stairs_dp {
+    /* Минимальная стоимость подъема по лестнице: динамическое программирование */
+    public static int minCostClimbingStairsDP(int[] cost) {
+        int n = cost.length - 1;
+        if (n == 1 || n == 2)
+            return cost[n];
+        // Инициализация таблицы dp для хранения решений подзадач
+        int[] dp = new int[n + 1];
+        // Начальное состояние: заранее задать решения наименьших подзадач
+        dp[1] = cost[1];
+        dp[2] = cost[2];
+        // Переход состояний: постепенное решение больших подзадач через меньшие
+        for (int i = 3; i <= n; i++) {
+            dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];
+        }
+        return dp[n];
+    }
+
+    /* Минимальная стоимость подъема по лестнице: динамическое программирование с оптимизацией памяти */
+    public static int minCostClimbingStairsDPComp(int[] cost) {
+        int n = cost.length - 1;
+        if (n == 1 || n == 2)
+            return cost[n];
+        int a = cost[1], b = cost[2];
+        for (int i = 3; i <= n; i++) {
+            int tmp = b;
+            b = Math.min(a, tmp) + cost[i];
+            a = tmp;
+        }
+        return b;
+    }
+
+    public static void main(String[] args) {
+        int[] cost = { 0, 1, 10, 1, 1, 1, 10, 1, 1, 10, 1 };
+        System.out.println(String.format("Список стоимостей ступеней = %s", Arrays.toString(cost)));
+
+        int res = minCostClimbingStairsDP(cost);
+        System.out.println(String.format("Минимальная стоимость подъема по лестнице = %d", res));
+
+        res = minCostClimbingStairsDPComp(cost);
+        System.out.println(String.format("Минимальная стоимость подъема по лестнице = %d", res));
+    }
+}

ru/codes/java/chapter_dynamic_programming/min_path_sum.java

@@ -0,0 +1,125 @@
+/**
+ * File: min_path_sum.java
+ * Created Time: 2023-07-10
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_dynamic_programming;
+
+import java.util.Arrays;
+
+public class min_path_sum {
+    /* Минимальная сумма пути: полный перебор */
+    static int minPathSumDFS(int[][] grid, int i, int j) {
+        // Если это верхняя левая ячейка, завершить поиск
+        if (i == 0 && j == 0) {
+            return grid[0][0];
+        }
+        // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞
+        if (i < 0 || j < 0) {
+            return Integer.MAX_VALUE;
+        }
+        // Вычислить минимальную стоимость пути из левого верхнего угла до (i-1, j) и (i, j-1)
+        int up = minPathSumDFS(grid, i - 1, j);
+        int left = minPathSumDFS(grid, i, j - 1);
+        // Вернуть минимальную стоимость пути из левого верхнего угла до (i, j)
+        return Math.min(left, up) + grid[i][j];
+    }
+
+    /* Минимальная сумма пути: поиск с мемоизацией */
+    static int minPathSumDFSMem(int[][] grid, int[][] mem, int i, int j) {
+        // Если это верхняя левая ячейка, завершить поиск
+        if (i == 0 && j == 0) {
+            return grid[0][0];
+        }
+        // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞
+        if (i < 0 || j < 0) {
+            return Integer.MAX_VALUE;
+        }
+        // Если запись уже есть, вернуть сразу
+        if (mem[i][j] != -1) {
+            return mem[i][j];
+        }
+        // Минимальная стоимость пути для левой и верхней ячеек
+        int up = minPathSumDFSMem(grid, mem, i - 1, j);
+        int left = minPathSumDFSMem(grid, mem, i, j - 1);
+        // Сохранить и вернуть минимальную стоимость пути из левого верхнего угла до (i, j)
+        mem[i][j] = Math.min(left, up) + grid[i][j];
+        return mem[i][j];
+    }
+
+    /* Минимальная сумма пути: динамическое программирование */
+    static int minPathSumDP(int[][] grid) {
+        int n = grid.length, m = grid[0].length;
+        // Инициализация таблицы dp
+        int[][] dp = new int[n][m];
+        dp[0][0] = grid[0][0];
+        // Переход состояний: первая строка
+        for (int j = 1; j < m; j++) {
+            dp[0][j] = dp[0][j - 1] + grid[0][j];
+        }
+        // Переход состояний: первый столбец
+        for (int i = 1; i < n; i++) {
+            dp[i][0] = dp[i - 1][0] + grid[i][0];
+        }
+        // Переход состояний: остальные строки и столбцы
+        for (int i = 1; i < n; i++) {
+            for (int j = 1; j < m; j++) {
+                dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];
+            }
+        }
+        return dp[n - 1][m - 1];
+    }
+
+    /* Минимальная сумма пути: динамическое программирование с оптимизацией памяти */
+    static int minPathSumDPComp(int[][] grid) {
+        int n = grid.length, m = grid[0].length;
+        // Инициализация таблицы dp
+        int[] dp = new int[m];
+        // Переход состояний: первая строка
+        dp[0] = grid[0][0];
+        for (int j = 1; j < m; j++) {
+            dp[j] = dp[j - 1] + grid[0][j];
+        }
+        // Переход состояний: остальные строки
+        for (int i = 1; i < n; i++) {
+            // Переход состояний: первый столбец
+            dp[0] = dp[0] + grid[i][0];
+            // Переход состояний: остальные столбцы
+            for (int j = 1; j < m; j++) {
+                dp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];
+            }
+        }
+        return dp[m - 1];
+    }
+
+    public static void main(String[] args) {
+        int[][] grid = {
+                { 1, 3, 1, 5 },
+                { 2, 2, 4, 2 },
+                { 5, 3, 2, 1 },
+                { 4, 3, 5, 2 }
+        };
+        int n = grid.length, m = grid[0].length;
+
+        // Полный перебор
+        int res = minPathSumDFS(grid, n - 1, m - 1);
+        System.out.println("Минимальная сумма пути из левого верхнего угла в правый нижний = " + res);
+
+        // Поиск с мемоизацией
+        int[][] mem = new int[n][m];
+        for (int[] row : mem) {
+            Arrays.fill(row, -1);
+        }
+        res = minPathSumDFSMem(grid, mem, n - 1, m - 1);
+        System.out.println("Минимальная сумма пути из левого верхнего угла в правый нижний = " + res);
+
+        // Динамическое программирование
+        res = minPathSumDP(grid);
+        System.out.println("Минимальная сумма пути из левого верхнего угла в правый нижний = " + res);
+
+        // Динамическое программирование с оптимизацией памяти
+        res = minPathSumDPComp(grid);
+        System.out.println("Минимальная сумма пути из левого верхнего угла в правый нижний = " + res);
+    }
+}

ru/codes/java/chapter_dynamic_programming/unbounded_knapsack.java

@@ -0,0 +1,63 @@
+/**
+ * File: unbounded_knapsack.java
+ * Created Time: 2023-07-11
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_dynamic_programming;
+
+public class unbounded_knapsack {
+    /* Полный рюкзак: динамическое программирование */
+    static int unboundedKnapsackDP(int[] wgt, int[] val, int cap) {
+        int n = wgt.length;
+        // Инициализация таблицы dp
+        int[][] dp = new int[n + 1][cap + 1];
+        // Переход состояний
+        for (int i = 1; i <= n; i++) {
+            for (int c = 1; c <= cap; c++) {
+                if (wgt[i - 1] > c) {
+                    // Если вместимость рюкзака превышена, предмет i не выбирать
+                    dp[i][c] = dp[i - 1][c];
+                } else {
+                    // Большее из двух решений: не брать или взять предмет i
+                    dp[i][c] = Math.max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);
+                }
+            }
+        }
+        return dp[n][cap];
+    }
+
+    /* Полный рюкзак: динамическое программирование с оптимизацией памяти */
+    static int unboundedKnapsackDPComp(int[] wgt, int[] val, int cap) {
+        int n = wgt.length;
+        // Инициализация таблицы dp
+        int[] dp = new int[cap + 1];
+        // Переход состояний
+        for (int i = 1; i <= n; i++) {
+            for (int c = 1; c <= cap; c++) {
+                if (wgt[i - 1] > c) {
+                    // Если вместимость рюкзака превышена, предмет i не выбирать
+                    dp[c] = dp[c];
+                } else {
+                    // Большее из двух решений: не брать или взять предмет i
+                    dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);
+                }
+            }
+        }
+        return dp[cap];
+    }
+
+    public static void main(String[] args) {
+        int[] wgt = { 1, 2, 3 };
+        int[] val = { 5, 11, 15 };
+        int cap = 4;
+
+        // Динамическое программирование
+        int res = unboundedKnapsackDP(wgt, val, cap);
+        System.out.println("Максимальная стоимость предметов без превышения вместимости рюкзака = " + res);
+
+        // Динамическое программирование с оптимизацией памяти
+        res = unboundedKnapsackDPComp(wgt, val, cap);
+        System.out.println("Максимальная стоимость предметов без превышения вместимости рюкзака = " + res);
+    }
+}

ru/codes/java/chapter_graph/graph_adjacency_list.java

@@ -0,0 +1,117 @@
+/**
+ * File: graph_adjacency_list.java
+ * Created Time: 2023-01-26
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_graph;
+
+import java.util.*;
+import utils.*;
+
+/* Класс неориентированного графа на основе списка смежности */
+class GraphAdjList {
+    // Список смежности, где key — вершина, а value — все смежные ей вершины
+    Map<Vertex, List<Vertex>> adjList;
+
+    /* Конструктор */
+    public GraphAdjList(Vertex[][] edges) {
+        this.adjList = new HashMap<>();
+        // Добавить все вершины и ребра
+        for (Vertex[] edge : edges) {
+            addVertex(edge[0]);
+            addVertex(edge[1]);
+            addEdge(edge[0], edge[1]);
+        }
+    }
+
+    /* Получить число вершин */
+    public int size() {
+        return adjList.size();
+    }
+
+    /* Добавление ребра */
+    public void addEdge(Vertex vet1, Vertex vet2) {
+        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)
+            throw new IllegalArgumentException();
+        // Добавить ребро vet1 - vet2
+        adjList.get(vet1).add(vet2);
+        adjList.get(vet2).add(vet1);
+    }
+
+    /* Удаление ребра */
+    public void removeEdge(Vertex vet1, Vertex vet2) {
+        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)
+            throw new IllegalArgumentException();
+        // Удалить ребро vet1 - vet2
+        adjList.get(vet1).remove(vet2);
+        adjList.get(vet2).remove(vet1);
+    }
+
+    /* Добавление вершины */
+    public void addVertex(Vertex vet) {
+        if (adjList.containsKey(vet))
+            return;
+        // Добавить новый список в список смежности
+        adjList.put(vet, new ArrayList<>());
+    }
+
+    /* Удаление вершины */
+    public void removeVertex(Vertex vet) {
+        if (!adjList.containsKey(vet))
+            throw new IllegalArgumentException();
+        // Удалить из списка смежности список, соответствующий вершине vet
+        adjList.remove(vet);
+        // Обойти списки других вершин и удалить все ребра, содержащие vet
+        for (List<Vertex> list : adjList.values()) {
+            list.remove(vet);
+        }
+    }
+
+    /* Вывести список смежности */
+    public void print() {
+        System.out.println("Список смежности =");
+        for (Map.Entry<Vertex, List<Vertex>> pair : adjList.entrySet()) {
+            List<Integer> tmp = new ArrayList<>();
+            for (Vertex vertex : pair.getValue())
+                tmp.add(vertex.val);
+            System.out.println(pair.getKey().val + ": " + tmp + ",");
+        }
+    }
+}
+
+public class graph_adjacency_list {
+    public static void main(String[] args) {
+        /* Инициализация неориентированного графа */
+        Vertex[] v = Vertex.valsToVets(new int[] { 1, 3, 2, 5, 4 });
+        Vertex[][] edges = { { v[0], v[1] }, { v[0], v[3] }, { v[1], v[2] },
+                             { v[2], v[3] }, { v[2], v[4] }, { v[3], v[4] } };
+        GraphAdjList graph = new GraphAdjList(edges);
+        System.out.println("\nГраф после инициализации");
+        graph.print();
+
+        /* Добавление ребра */
+        // Вершины 1 и 2 соответствуют v[0] и v[2]
+        graph.addEdge(v[0], v[2]);
+        System.out.println("\nГраф после добавления ребра 1-2");
+        graph.print();
+
+        /* Удаление ребра */
+        // Вершины 1 и 3 соответствуют v[0] и v[1]
+        graph.removeEdge(v[0], v[1]);
+        System.out.println("\nГраф после удаления ребра 1-3");
+        graph.print();
+
+        /* Добавление вершины */
+        Vertex v5 = new Vertex(6);
+        graph.addVertex(v5);
+        System.out.println("\nГраф после добавления вершины 6");
+        graph.print();
+
+        /* Удаление вершины */
+        // Вершина 3 соответствует v[1]
+        graph.removeVertex(v[1]);
+        System.out.println("\nГраф после удаления вершины 3");
+        graph.print();
+    }
+}

ru/codes/java/chapter_graph/graph_adjacency_matrix.java

@@ -0,0 +1,131 @@
+/**
+ * File: graph_adjacency_matrix.java
+ * Created Time: 2023-01-26
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_graph;
+
+import utils.*;
+import java.util.*;
+
+/* Класс неориентированного графа на основе матрицы смежности */
+class GraphAdjMat {
+    List<Integer> vertices; // Список вершин: элементы представляют «значения вершин», а индексы — «индексы вершин»
+    List<List<Integer>> adjMat; // Матрица смежности, где индексы строк и столбцов соответствуют «индексам вершин»
+
+    /* Конструктор */
+    public GraphAdjMat(int[] vertices, int[][] edges) {
+        this.vertices = new ArrayList<>();
+        this.adjMat = new ArrayList<>();
+        // Добавление вершины
+        for (int val : vertices) {
+            addVertex(val);
+        }
+        // Добавить ребра
+        // Обратите внимание: элементы edges представляют собой индексы вершин, то есть соответствуют индексам элементов vertices
+        for (int[] e : edges) {
+            addEdge(e[0], e[1]);
+        }
+    }
+
+    /* Получить число вершин */
+    public int size() {
+        return vertices.size();
+    }
+
+    /* Добавление вершины */
+    public void addVertex(int val) {
+        int n = size();
+        // Добавить значение новой вершины в список вершин
+        vertices.add(val);
+        // Добавить строку в матрицу смежности
+        List<Integer> newRow = new ArrayList<>(n);
+        for (int j = 0; j < n; j++) {
+            newRow.add(0);
+        }
+        adjMat.add(newRow);
+        // Добавить столбец в матрицу смежности
+        for (List<Integer> row : adjMat) {
+            row.add(0);
+        }
+    }
+
+    /* Удаление вершины */
+    public void removeVertex(int index) {
+        if (index >= size())
+            throw new IndexOutOfBoundsException();
+        // Удалить вершину с индексом index из списка вершин
+        vertices.remove(index);
+        // Удалить строку с индексом index из матрицы смежности
+        adjMat.remove(index);
+        // Удалить столбец с индексом index из матрицы смежности
+        for (List<Integer> row : adjMat) {
+            row.remove(index);
+        }
+    }
+
+    /* Добавление ребра */
+    // Параметры i и j соответствуют индексам элементов vertices
+    public void addEdge(int i, int j) {
+        // Обработка выхода индекса за границы и случая равенства
+        if (i < 0 || j < 0 || i >= size() || j >= size() || i == j)
+            throw new IndexOutOfBoundsException();
+        // В неориентированном графе матрица смежности симметрична относительно главной диагонали, то есть выполняется (i, j) == (j, i)
+        adjMat.get(i).set(j, 1);
+        adjMat.get(j).set(i, 1);
+    }
+
+    /* Удаление ребра */
+    // Параметры i и j соответствуют индексам элементов vertices
+    public void removeEdge(int i, int j) {
+        // Обработка выхода индекса за границы и случая равенства
+        if (i < 0 || j < 0 || i >= size() || j >= size() || i == j)
+            throw new IndexOutOfBoundsException();
+        adjMat.get(i).set(j, 0);
+        adjMat.get(j).set(i, 0);
+    }
+
+    /* Вывести матрицу смежности */
+    public void print() {
+        System.out.print("Список вершин = ");
+        System.out.println(vertices);
+        System.out.println("Матрица смежности =");
+        PrintUtil.printMatrix(adjMat);
+    }
+}
+
+public class graph_adjacency_matrix {
+    public static void main(String[] args) {
+        /* Инициализация неориентированного графа */
+        // Обратите внимание: элементы edges представляют индексы вершин, то есть соответствуют индексам элементов vertices
+        int[] vertices = { 1, 3, 2, 5, 4 };
+        int[][] edges = { { 0, 1 }, { 0, 3 }, { 1, 2 }, { 2, 3 }, { 2, 4 }, { 3, 4 } };
+        GraphAdjMat graph = new GraphAdjMat(vertices, edges);
+        System.out.println("\nГраф после инициализации");
+        graph.print();
+
+        /* Добавление ребра */
+        // Индексы вершин 1 и 2 равны 0 и 2 соответственно
+        graph.addEdge(0, 2);
+        System.out.println("\nГраф после добавления ребра 1-2");
+        graph.print();
+
+        /* Удаление ребра */
+        // Индексы вершин 1 и 3 равны 0 и 1 соответственно
+        graph.removeEdge(0, 1);
+        System.out.println("\nГраф после удаления ребра 1-3");
+        graph.print();
+
+        /* Добавление вершины */
+        graph.addVertex(6);
+        System.out.println("\nГраф после добавления вершины 6");
+        graph.print();
+
+        /* Удаление вершины */
+        // Индекс вершины 3 равен 1
+        graph.removeVertex(1);
+        System.out.println("\nГраф после удаления вершины 3");
+        graph.print();
+    }
+}

ru/codes/java/chapter_graph/graph_bfs.java

@@ -0,0 +1,55 @@
+/**
+ * File: graph_bfs.java
+ * Created Time: 2023-02-12
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_graph;
+
+import java.util.*;
+import utils.*;
+
+public class graph_bfs {
+    /* Обход в ширину */
+    // Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины
+    static List<Vertex> graphBFS(GraphAdjList graph, Vertex startVet) {
+        // Последовательность обхода вершин
+        List<Vertex> res = new ArrayList<>();
+        // Хеш-множество для хранения уже посещенных вершин
+        Set<Vertex> visited = new HashSet<>();
+        visited.add(startVet);
+        // Очередь используется для реализации BFS
+        Queue<Vertex> que = new LinkedList<>();
+        que.offer(startVet);
+        // Начиная с вершины vet, продолжать цикл, пока не будут посещены все вершины
+        while (!que.isEmpty()) {
+            Vertex vet = que.poll(); // Извлечь головную вершину из очереди
+            res.add(vet);            // Отметить посещенную вершину
+            // Обойти все смежные вершины данной вершины
+            for (Vertex adjVet : graph.adjList.get(vet)) {
+                if (visited.contains(adjVet))
+                    continue;        // Пропустить уже посещенную вершину
+                que.offer(adjVet);   // Помещать в очередь только непосещенные вершины
+                visited.add(adjVet); // Отметить эту вершину как посещенную
+            }
+        }
+        // Вернуть последовательность обхода вершин
+        return res;
+    }
+
+    public static void main(String[] args) {
+        /* Инициализация неориентированного графа */
+        Vertex[] v = Vertex.valsToVets(new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
+        Vertex[][] edges = { { v[0], v[1] }, { v[0], v[3] }, { v[1], v[2] }, { v[1], v[4] },
+                             { v[2], v[5] }, { v[3], v[4] }, { v[3], v[6] }, { v[4], v[5] },
+                             { v[4], v[7] }, { v[5], v[8] }, { v[6], v[7] }, { v[7], v[8] } };
+        GraphAdjList graph = new GraphAdjList(edges);
+        System.out.println("\nГраф после инициализации");
+        graph.print();
+
+        /* Обход в ширину */
+        List<Vertex> res = graphBFS(graph, v[0]);
+        System.out.println("\nПоследовательность вершин при обходе в ширину (BFS)");
+        System.out.println(Vertex.vetsToVals(res));
+    }
+}

ru/codes/java/chapter_graph/graph_dfs.java

@@ -0,0 +1,51 @@
+/**
+ * File: graph_dfs.java
+ * Created Time: 2023-02-12
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_graph;
+
+import java.util.*;
+import utils.*;
+
+public class graph_dfs {
+    /* Вспомогательная функция обхода в глубину */
+    static void dfs(GraphAdjList graph, Set<Vertex> visited, List<Vertex> res, Vertex vet) {
+        res.add(vet);     // Отметить посещенную вершину
+        visited.add(vet); // Отметить эту вершину как посещенную
+        // Обойти все смежные вершины данной вершины
+        for (Vertex adjVet : graph.adjList.get(vet)) {
+            if (visited.contains(adjVet))
+                continue; // Пропустить уже посещенную вершину
+            // Рекурсивно обходить смежные вершины
+            dfs(graph, visited, res, adjVet);
+        }
+    }
+
+    /* Обход в глубину */
+    // Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины
+    static List<Vertex> graphDFS(GraphAdjList graph, Vertex startVet) {
+        // Последовательность обхода вершин
+        List<Vertex> res = new ArrayList<>();
+        // Хеш-множество для хранения уже посещенных вершин
+        Set<Vertex> visited = new HashSet<>();
+        dfs(graph, visited, res, startVet);
+        return res;
+    }
+
+    public static void main(String[] args) {
+        /* Инициализация неориентированного графа */
+        Vertex[] v = Vertex.valsToVets(new int[] { 0, 1, 2, 3, 4, 5, 6 });
+        Vertex[][] edges = { { v[0], v[1] }, { v[0], v[3] }, { v[1], v[2] },
+                             { v[2], v[5] }, { v[4], v[5] }, { v[5], v[6] } };
+        GraphAdjList graph = new GraphAdjList(edges);
+        System.out.println("\nГраф после инициализации");
+        graph.print();
+
+        /* Обход в глубину */
+        List<Vertex> res = graphDFS(graph, v[0]);
+        System.out.println("\nПоследовательность вершин при обходе в глубину (DFS)");
+        System.out.println(Vertex.vetsToVals(res));
+    }
+}

ru/codes/java/chapter_greedy/coin_change_greedy.java

@@ -0,0 +1,55 @@
+/**
+ * File: coin_change_greedy.java
+ * Created Time: 2023-07-20
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_greedy;
+
+import java.util.Arrays;
+
+public class coin_change_greedy {
+    /* Размен монет: жадный алгоритм */
+    static int coinChangeGreedy(int[] coins, int amt) {
+        // Предположить, что список coins упорядочен
+        int i = coins.length - 1;
+        int count = 0;
+        // Циклически выполнять жадный выбор, пока не останется суммы
+        while (amt > 0) {
+            // Найти монету, которая меньше остатка суммы и наиболее к нему близка
+            while (i > 0 && coins[i] > amt) {
+                i--;
+            }
+            // Выбрать coins[i]
+            amt -= coins[i];
+            count++;
+        }
+        // Если допустимое решение не найдено, вернуть -1
+        return amt == 0 ? count : -1;
+    }
+
+    public static void main(String[] args) {
+        // Жадный подход: гарантирует нахождение глобально оптимального решения
+        int[] coins = { 1, 5, 10, 20, 50, 100 };
+        int amt = 186;
+        int res = coinChangeGreedy(coins, amt);
+        System.out.println("\ncoins = " + Arrays.toString(coins) + ", amt = " + amt);
+        System.out.println("Минимальное число монет для набора суммы " + amt + " = " + res);
+
+        // Жадный подход: не гарантирует нахождение глобально оптимального решения
+        coins = new int[] { 1, 20, 50 };
+        amt = 60;
+        res = coinChangeGreedy(coins, amt);
+        System.out.println("\ncoins = " + Arrays.toString(coins) + ", amt = " + amt);
+        System.out.println("Минимальное число монет для набора суммы " + amt + " = " + res);
+        System.out.println("На самом деле минимум равен 3: 20 + 20 + 20");
+
+        // Жадный подход: не гарантирует нахождение глобально оптимального решения
+        coins = new int[] { 1, 49, 50 };
+        amt = 98;
+        res = coinChangeGreedy(coins, amt);
+        System.out.println("\ncoins = " + Arrays.toString(coins) + ", amt = " + amt);
+        System.out.println("Минимальное число монет для набора суммы " + amt + " = " + res);
+        System.out.println("На самом деле минимум равен 2: 49 + 49");
+    }
+}

ru/codes/java/chapter_greedy/fractional_knapsack.java

@@ -0,0 +1,59 @@
+/**
+ * File: fractional_knapsack.java
+ * Created Time: 2023-07-20
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_greedy;
+
+import java.util.Arrays;
+import java.util.Comparator;
+
+/* Предмет */
+class Item {
+    int w; // Вес предмета
+    int v; // Стоимость предмета
+
+    public Item(int w, int v) {
+        this.w = w;
+        this.v = v;
+    }
+}
+
+public class fractional_knapsack {
+    /* Дробный рюкзак: жадный алгоритм */
+    static double fractionalKnapsack(int[] wgt, int[] val, int cap) {
+        // Создать список предметов с двумя свойствами: вес и стоимость
+        Item[] items = new Item[wgt.length];
+        for (int i = 0; i < wgt.length; i++) {
+            items[i] = new Item(wgt[i], val[i]);
+        }
+        // Отсортировать по удельной стоимости item.v / item.w в порядке убывания
+        Arrays.sort(items, Comparator.comparingDouble(item -> -((double) item.v / item.w)));
+        // Циклический жадный выбор
+        double res = 0;
+        for (Item item : items) {
+            if (item.w <= cap) {
+                // Если оставшейся вместимости достаточно, положить в рюкзак текущий предмет целиком
+                res += item.v;
+                cap -= item.w;
+            } else {
+                // Если оставшейся вместимости недостаточно, положить в рюкзак часть текущего предмета
+                res += (double) item.v / item.w * cap;
+                // Свободной вместимости больше не осталось, поэтому выйти из цикла
+                break;
+            }
+        }
+        return res;
+    }
+
+    public static void main(String[] args) {
+        int[] wgt = { 10, 20, 30, 40, 50 };
+        int[] val = { 50, 120, 150, 210, 240 };
+        int cap = 50;
+
+        // Жадный алгоритм
+        double res = fractionalKnapsack(wgt, val, cap);
+        System.out.println("Максимальная стоимость предметов без превышения вместимости рюкзака = " + res);
+    }
+}

ru/codes/java/chapter_greedy/max_capacity.java

@@ -0,0 +1,38 @@
+/**
+ * File: max_capacity.java
+ * Created Time: 2023-07-21
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_greedy;
+
+public class max_capacity {
+    /* Максимальная вместимость: жадный алгоритм */
+    static int maxCapacity(int[] ht) {
+        // Инициализировать i и j так, чтобы они располагались по двум концам массива
+        int i = 0, j = ht.length - 1;
+        // Начальная максимальная вместимость равна 0
+        int res = 0;
+        // Выполнять жадный выбор в цикле, пока две доски не встретятся
+        while (i < j) {
+            // Обновить максимальную вместимость
+            int cap = Math.min(ht[i], ht[j]) * (j - i);
+            res = Math.max(res, cap);
+            // Сдвигать внутрь более короткую сторону
+            if (ht[i] < ht[j]) {
+                i++;
+            } else {
+                j--;
+            }
+        }
+        return res;
+    }
+
+    public static void main(String[] args) {
+        int[] ht = { 3, 8, 5, 2, 7, 7, 3, 4 };
+
+        // Жадный алгоритм
+        int res = maxCapacity(ht);
+        System.out.println("Максимальная вместимость = " + res);
+    }
+}

ru/codes/java/chapter_greedy/max_product_cutting.java

@@ -0,0 +1,40 @@
+/**
+ * File: max_product_cutting.java
+ * Created Time: 2023-07-21
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_greedy;
+
+import java.lang.Math;
+
+public class max_product_cutting {
+    /* Максимальное произведение разрезания: жадный алгоритм */
+    public static int maxProductCutting(int n) {
+        // Когда n <= 3, обязательно нужно выделить одну 1
+        if (n <= 3) {
+            return 1 * (n - 1);
+        }
+        // Жадно выделить множители 3, где a — число троек, а b — остаток
+        int a = n / 3;
+        int b = n % 3;
+        if (b == 1) {
+            // Если остаток равен 1, преобразовать одну пару 1 * 3 в 2 * 2
+            return (int) Math.pow(3, a - 1) * 2 * 2;
+        }
+        if (b == 2) {
+            // Если остаток равен 2, ничего не делать
+            return (int) Math.pow(3, a) * 2;
+        }
+        // Если остаток равен 0, ничего не делать
+        return (int) Math.pow(3, a);
+    }
+
+    public static void main(String[] args) {
+        int n = 58;
+
+        // Жадный алгоритм
+        int res = maxProductCutting(n);
+        System.out.println("Максимальное произведение после разрезания = " + res);
+    }
+}

ru/codes/java/chapter_hashing/array_hash_map.java

@@ -0,0 +1,141 @@
+/**
+ * File: array_hash_map.java
+ * Created Time: 2022-12-04
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_hashing;
+
+import java.util.*;
+
+/* Пара ключ-значение */
+class Pair {
+    public int key;
+    public String val;
+
+    public Pair(int key, String val) {
+        this.key = key;
+        this.val = val;
+    }
+}
+
+/* Хеш-таблица на основе массива */
+class ArrayHashMap {
+    private List<Pair> buckets;
+
+    public ArrayHashMap() {
+        // Инициализировать массив, содержащий 100 корзин
+        buckets = new ArrayList<>();
+        for (int i = 0; i < 100; i++) {
+            buckets.add(null);
+        }
+    }
+
+    /* Хеш-функция */
+    private int hashFunc(int key) {
+        int index = key % 100;
+        return index;
+    }
+
+    /* Операция поиска */
+    public String get(int key) {
+        int index = hashFunc(key);
+        Pair pair = buckets.get(index);
+        if (pair == null)
+            return null;
+        return pair.val;
+    }
+
+    /* Операция добавления */
+    public void put(int key, String val) {
+        Pair pair = new Pair(key, val);
+        int index = hashFunc(key);
+        buckets.set(index, pair);
+    }
+
+    /* Операция удаления */
+    public void remove(int key) {
+        int index = hashFunc(key);
+        // Присвоить null, что означает удаление
+        buckets.set(index, null);
+    }
+
+    /* Получить все пары ключ-значение */
+    public List<Pair> pairSet() {
+        List<Pair> pairSet = new ArrayList<>();
+        for (Pair pair : buckets) {
+            if (pair != null)
+                pairSet.add(pair);
+        }
+        return pairSet;
+    }
+
+    /* Получить все ключи */
+    public List<Integer> keySet() {
+        List<Integer> keySet = new ArrayList<>();
+        for (Pair pair : buckets) {
+            if (pair != null)
+                keySet.add(pair.key);
+        }
+        return keySet;
+    }
+
+    /* Получить все значения */
+    public List<String> valueSet() {
+        List<String> valueSet = new ArrayList<>();
+        for (Pair pair : buckets) {
+            if (pair != null)
+                valueSet.add(pair.val);
+        }
+        return valueSet;
+    }
+
+    /* Вывести хеш-таблицу */
+    public void print() {
+        for (Pair kv : pairSet()) {
+            System.out.println(kv.key + " -> " + kv.val);
+        }
+    }
+}
+
+public class array_hash_map {
+    public static void main(String[] args) {
+        /* Инициализация хеш-таблицы */
+        ArrayHashMap map = new ArrayHashMap();
+
+        /* Операция добавления */
+        // Добавить пару (key, value) в хеш-таблицу
+        map.put(12836, "Сяо Ха");
+        map.put(15937, "Сяо Ло");
+        map.put(16750, "Сяо Суань");
+        map.put(13276, "Сяо Фа");
+        map.put(10583, "Сяо Я");
+        System.out.println("\nПосле добавления хеш-таблица имеет вид\nКлюч -> Значение");
+        map.print();
+
+        /* Операция поиска */
+        // Ввести в хеш-таблицу ключ key и получить значение value
+        String name = map.get(15937);
+        System.out.println("\nДля номера 15937 найдено имя " + name);
+
+        /* Операция удаления */
+        // Удалить пару (key, value) из хеш-таблицы
+        map.remove(10583);
+        System.out.println("\nПосле удаления 10583 хеш-таблица имеет вид\nКлюч -> Значение");
+        map.print();
+
+        /* Обход хеш-таблицы */
+        System.out.println("\nОтдельный обход пар ключ-значение");
+        for (Pair kv : map.pairSet()) {
+            System.out.println(kv.key + " -> " + kv.val);
+        }
+        System.out.println("\nОтдельный обход ключей");
+        for (int key : map.keySet()) {
+            System.out.println(key);
+        }
+        System.out.println("\nОтдельный обход значений");
+        for (String val : map.valueSet()) {
+            System.out.println(val);
+        }
+    }
+}

ru/codes/java/chapter_hashing/built_in_hash.java

@@ -0,0 +1,38 @@
+/**
+ * File: built_in_hash.java
+ * Created Time: 2023-06-21
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_hashing;
+
+import utils.*;
+import java.util.*;
+
+public class built_in_hash {
+    public static void main(String[] args) {
+        int num = 3;
+        int hashNum = Integer.hashCode(num);
+        System.out.println("Хеш-значение целого числа " + num + " = " + hashNum);
+
+        boolean bol = true;
+        int hashBol = Boolean.hashCode(bol);
+        System.out.println("Хеш-значение булева значения " + bol + " = " + hashBol);
+
+        double dec = 3.14159;
+        int hashDec = Double.hashCode(dec);
+        System.out.println("Хеш-значение десятичного числа " + dec + " = " + hashDec);
+
+        String str = "Hello Algo";
+        int hashStr = str.hashCode();
+        System.out.println("Хеш-значение строки " + str + " = " + hashStr);
+
+        Object[] arr = { 12836, "Сяо Ха" };
+        int hashTup = Arrays.hashCode(arr);
+        System.out.println("Хеш-значение массива " + Arrays.toString(arr) + " = " + hashTup);
+
+        ListNode obj = new ListNode(0);
+        int hashObj = obj.hashCode();
+        System.out.println("Хеш-значение объекта узла " + obj + " = " + hashObj);
+    }
+}

ru/codes/java/chapter_hashing/hash_map.java

@@ -0,0 +1,52 @@
+/**
+ * File: hash_map.java
+ * Created Time: 2022-12-04
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_hashing;
+
+import java.util.*;
+import utils.*;
+
+public class hash_map {
+    public static void main(String[] args) {
+        /* Инициализация хеш-таблицы */
+        Map<Integer, String> map = new HashMap<>();
+
+        /* Операция добавления */
+        // Добавить пару (key, value) в хеш-таблицу
+        map.put(12836, "Сяо Ха");
+        map.put(15937, "Сяо Ло");
+        map.put(16750, "Сяо Суань");
+        map.put(13276, "Сяо Фа");
+        map.put(10583, "Сяо Я");
+        System.out.println("\nПосле добавления хеш-таблица имеет вид\nКлюч -> Значение");
+        PrintUtil.printHashMap(map);
+
+        /* Операция поиска */
+        // Ввести в хеш-таблицу ключ key и получить значение value
+        String name = map.get(15937);
+        System.out.println("\nДля номера 15937 найдено имя " + name);
+
+        /* Операция удаления */
+        // Удалить пару (key, value) из хеш-таблицы
+        map.remove(10583);
+        System.out.println("\nПосле удаления 10583 хеш-таблица имеет вид\nКлюч -> Значение");
+        PrintUtil.printHashMap(map);
+
+        /* Обход хеш-таблицы */
+        System.out.println("\nОтдельный обход пар ключ-значение");
+        for (Map.Entry<Integer, String> kv : map.entrySet()) {
+            System.out.println(kv.getKey() + " -> " + kv.getValue());
+        }
+        System.out.println("\nОтдельный обход ключей");
+        for (int key : map.keySet()) {
+            System.out.println(key);
+        }
+        System.out.println("\nОтдельный обход значений");
+        for (String val : map.values()) {
+            System.out.println(val);
+        }
+    }
+}

ru/codes/java/chapter_hashing/hash_map_chaining.java

@@ -0,0 +1,148 @@
+/**
+ * File: hash_map_chaining.java
+ * Created Time: 2023-06-13
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_hashing;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/* Хеш-таблица с цепочками */
+class HashMapChaining {
+    int size; // Число пар ключ-значение
+    int capacity; // Вместимость хеш-таблицы
+    double loadThres; // Порог коэффициента загрузки для запуска расширения
+    int extendRatio; // Коэффициент расширения
+    List<List<Pair>> buckets; // Массив корзин
+
+    /* Конструктор */
+    public HashMapChaining() {
+        size = 0;
+        capacity = 4;
+        loadThres = 2.0 / 3.0;
+        extendRatio = 2;
+        buckets = new ArrayList<>(capacity);
+        for (int i = 0; i < capacity; i++) {
+            buckets.add(new ArrayList<>());
+        }
+    }
+
+    /* Хеш-функция */
+    int hashFunc(int key) {
+        return key % capacity;
+    }
+
+    /* Коэффициент загрузки */
+    double loadFactor() {
+        return (double) size / capacity;
+    }
+
+    /* Операция поиска */
+    String get(int key) {
+        int index = hashFunc(key);
+        List<Pair> bucket = buckets.get(index);
+        // Обойти корзину; если найден key, вернуть соответствующее val
+        for (Pair pair : bucket) {
+            if (pair.key == key) {
+                return pair.val;
+            }
+        }
+        // Если key не найден, вернуть null
+        return null;
+    }
+
+    /* Операция добавления */
+    void put(int key, String val) {
+        // Когда коэффициент загрузки превышает порог, выполнить расширение
+        if (loadFactor() > loadThres) {
+            extend();
+        }
+        int index = hashFunc(key);
+        List<Pair> bucket = buckets.get(index);
+        // Обойти корзину; если встретился указанный key, обновить соответствующее val и вернуть
+        for (Pair pair : bucket) {
+            if (pair.key == key) {
+                pair.val = val;
+                return;
+            }
+        }
+        // Если такого key нет, добавить пару ключ-значение в конец
+        Pair pair = new Pair(key, val);
+        bucket.add(pair);
+        size++;
+    }
+
+    /* Операция удаления */
+    void remove(int key) {
+        int index = hashFunc(key);
+        List<Pair> bucket = buckets.get(index);
+        // Обойти корзину и удалить из нее пару ключ-значение
+        for (Pair pair : bucket) {
+            if (pair.key == key) {
+                bucket.remove(pair);
+                size--;
+                break;
+            }
+        }
+    }
+
+    /* Расширить хеш-таблицу */
+    void extend() {
+        // Временно сохранить исходную хеш-таблицу
+        List<List<Pair>> bucketsTmp = buckets;
+        // Инициализация новой хеш-таблицы после расширения
+        capacity *= extendRatio;
+        buckets = new ArrayList<>(capacity);
+        for (int i = 0; i < capacity; i++) {
+            buckets.add(new ArrayList<>());
+        }
+        size = 0;
+        // Перенести пары ключ-значение из исходной хеш-таблицы в новую
+        for (List<Pair> bucket : bucketsTmp) {
+            for (Pair pair : bucket) {
+                put(pair.key, pair.val);
+            }
+        }
+    }
+
+    /* Вывести хеш-таблицу */
+    void print() {
+        for (List<Pair> bucket : buckets) {
+            List<String> res = new ArrayList<>();
+            for (Pair pair : bucket) {
+                res.add(pair.key + " -> " + pair.val);
+            }
+            System.out.println(res);
+        }
+    }
+}
+
+public class hash_map_chaining {
+    public static void main(String[] args) {
+        /* Инициализация хеш-таблицы */
+        HashMapChaining map = new HashMapChaining();
+
+        /* Операция добавления */
+        // Добавить пару (key, value) в хеш-таблицу
+        map.put(12836, "Сяо Ха");
+        map.put(15937, "Сяо Ло");
+        map.put(16750, "Сяо Суань");
+        map.put(13276, "Сяо Фа");
+        map.put(10583, "Сяо Я");
+        System.out.println("\nПосле добавления хеш-таблица имеет вид\nКлюч -> Значение");
+        map.print();
+
+        /* Операция поиска */
+        // Ввести в хеш-таблицу ключ key и получить значение value
+        String name = map.get(13276);
+        System.out.println("\nДля номера 13276 найдено имя " + name);
+
+        /* Операция удаления */
+        // Удалить пару (key, value) из хеш-таблицы
+        map.remove(12836);
+        System.out.println("\nПосле удаления 12836 хеш-таблица имеет вид\nКлюч -> Значение");
+        map.print();
+    }
+}

ru/codes/java/chapter_hashing/hash_map_open_addressing.java

@@ -0,0 +1,158 @@
+/**
+ * File: hash_map_open_addressing.java
+ * Created Time: 2023-06-13
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_hashing;
+
+/* Хеш-таблица с открытой адресацией */
+class HashMapOpenAddressing {
+    private int size; // Число пар ключ-значение
+    private int capacity = 4; // Вместимость хеш-таблицы
+    private final double loadThres = 2.0 / 3.0; // Порог коэффициента загрузки для запуска расширения
+    private final int extendRatio = 2; // Коэффициент расширения
+    private Pair[] buckets; // Массив корзин
+    private final Pair TOMBSTONE = new Pair(-1, "-1"); // Удалить метку
+
+    /* Конструктор */
+    public HashMapOpenAddressing() {
+        size = 0;
+        buckets = new Pair[capacity];
+    }
+
+    /* Хеш-функция */
+    private int hashFunc(int key) {
+        return key % capacity;
+    }
+
+    /* Коэффициент загрузки */
+    private double loadFactor() {
+        return (double) size / capacity;
+    }
+
+    /* Найти индекс корзины, соответствующий key */
+    private int findBucket(int key) {
+        int index = hashFunc(key);
+        int firstTombstone = -1;
+        // Выполнять линейное пробирование и завершить при встрече с пустой корзиной
+        while (buckets[index] != null) {
+            // Если встретился key, вернуть соответствующий индекс корзины
+            if (buckets[index].key == key) {
+                // Если ранее встретилась метка удаления, переместить пару ключ-значение на этот индекс
+                if (firstTombstone != -1) {
+                    buckets[firstTombstone] = buckets[index];
+                    buckets[index] = TOMBSTONE;
+                    return firstTombstone; // Вернуть индекс корзины после перемещения
+                }
+                return index; // Вернуть индекс корзины
+            }
+            // Записать первую встретившуюся метку удаления
+            if (firstTombstone == -1 && buckets[index] == TOMBSTONE) {
+                firstTombstone = index;
+            }
+            // Вычислить индекс корзины; при выходе за конец вернуться к началу
+            index = (index + 1) % capacity;
+        }
+        // Если key не существует, вернуть индекс точки добавления
+        return firstTombstone == -1 ? index : firstTombstone;
+    }
+
+    /* Операция поиска */
+    public String get(int key) {
+        // Найти индекс корзины, соответствующий key
+        int index = findBucket(key);
+        // Если пара ключ-значение найдена, вернуть соответствующее val
+        if (buckets[index] != null && buckets[index] != TOMBSTONE) {
+            return buckets[index].val;
+        }
+        // Если пары ключ-значение не существует, вернуть null
+        return null;
+    }
+
+    /* Операция добавления */
+    public void put(int key, String val) {
+        // Когда коэффициент загрузки превышает порог, выполнить расширение
+        if (loadFactor() > loadThres) {
+            extend();
+        }
+        // Найти индекс корзины, соответствующий key
+        int index = findBucket(key);
+        // Если пара ключ-значение найдена, перезаписать val и вернуть
+        if (buckets[index] != null && buckets[index] != TOMBSTONE) {
+            buckets[index].val = val;
+            return;
+        }
+        // Если пары ключ-значение нет, добавить ее
+        buckets[index] = new Pair(key, val);
+        size++;
+    }
+
+    /* Операция удаления */
+    public void remove(int key) {
+        // Найти индекс корзины, соответствующий key
+        int index = findBucket(key);
+        // Если пара ключ-значение найдена, заменить ее меткой удаления
+        if (buckets[index] != null && buckets[index] != TOMBSTONE) {
+            buckets[index] = TOMBSTONE;
+            size--;
+        }
+    }
+
+    /* Расширить хеш-таблицу */
+    private void extend() {
+        // Временно сохранить исходную хеш-таблицу
+        Pair[] bucketsTmp = buckets;
+        // Инициализация новой хеш-таблицы после расширения
+        capacity *= extendRatio;
+        buckets = new Pair[capacity];
+        size = 0;
+        // Перенести пары ключ-значение из исходной хеш-таблицы в новую
+        for (Pair pair : bucketsTmp) {
+            if (pair != null && pair != TOMBSTONE) {
+                put(pair.key, pair.val);
+            }
+        }
+    }
+
+    /* Вывести хеш-таблицу */
+    public void print() {
+        for (Pair pair : buckets) {
+            if (pair == null) {
+                System.out.println("null");
+            } else if (pair == TOMBSTONE) {
+                System.out.println("TOMBSTONE");
+            } else {
+                System.out.println(pair.key + " -> " + pair.val);
+            }
+        }
+    }
+}
+
+public class hash_map_open_addressing {
+    public static void main(String[] args) {
+        // Инициализация хеш-таблицы
+        HashMapOpenAddressing hashmap = new HashMapOpenAddressing();
+
+        // Операция добавления
+        // Добавить пару (key, val) в хеш-таблицу
+        hashmap.put(12836, "Сяо Ха");
+        hashmap.put(15937, "Сяо Ло");
+        hashmap.put(16750, "Сяо Суань");
+        hashmap.put(13276, "Сяо Фа");
+        hashmap.put(10583, "Сяо Я");
+        System.out.println("\nПосле добавления хеш-таблица имеет вид\nКлюч -> Значение");
+        hashmap.print();
+
+        // Операция поиска
+        // Передать ключ key в хеш-таблицу и получить значение val
+        String name = hashmap.get(13276);
+        System.out.println("\nДля номера 13276 найдено имя " + name);
+
+        // Операция удаления
+        // Удалить пару (key, val) из хеш-таблицы
+        hashmap.remove(16750);
+        System.out.println("\nПосле удаления 16750 хеш-таблица имеет вид\nКлюч -> Значение");
+        hashmap.print();
+    }
+}

ru/codes/java/chapter_hashing/simple_hash.java

@@ -0,0 +1,65 @@
+/**
+ * File: simple_hash.java
+ * Created Time: 2023-06-21
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_hashing;
+
+public class simple_hash {
+    /* Аддитивное хеширование */
+    static int addHash(String key) {
+        long hash = 0;
+        final int MODULUS = 1000000007;
+        for (char c : key.toCharArray()) {
+            hash = (hash + (int) c) % MODULUS;
+        }
+        return (int) hash;
+    }
+
+    /* Мультипликативное хеширование */
+    static int mulHash(String key) {
+        long hash = 0;
+        final int MODULUS = 1000000007;
+        for (char c : key.toCharArray()) {
+            hash = (31 * hash + (int) c) % MODULUS;
+        }
+        return (int) hash;
+    }
+
+    /* XOR-хеширование */
+    static int xorHash(String key) {
+        int hash = 0;
+        final int MODULUS = 1000000007;
+        for (char c : key.toCharArray()) {
+            hash ^= (int) c;
+        }
+        return hash & MODULUS;
+    }
+
+    /* Хеширование с циклическим сдвигом */
+    static int rotHash(String key) {
+        long hash = 0;
+        final int MODULUS = 1000000007;
+        for (char c : key.toCharArray()) {
+            hash = ((hash << 4) ^ (hash >> 28) ^ (int) c) % MODULUS;
+        }
+        return (int) hash;
+    }
+
+    public static void main(String[] args) {
+        String key = "Hello Algo";
+
+        int hash = addHash(key);
+        System.out.println("Хеш-сумма сложением = " + hash);
+
+        hash = mulHash(key);
+        System.out.println("Хеш-сумма умножением = " + hash);
+
+        hash = xorHash(key);
+        System.out.println("Хеш-сумма XOR = " + hash);
+
+        hash = rotHash(key);
+        System.out.println("Хеш-сумма с циклическим сдвигом = " + hash);
+    }
+}

ru/codes/java/chapter_heap/heap.java

@@ -0,0 +1,66 @@
+/**
+ * File: heap.java
+ * Created Time: 2023-01-07
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_heap;
+
+import utils.*;
+import java.util.*;
+
+public class heap {
+    public static void testPush(Queue<Integer> heap, int val) {
+        heap.offer(val); // Добавление элемента в кучу
+        System.out.format("\nПосле добавления элемента %d в кучу\n", val);
+        PrintUtil.printHeap(heap);
+    }
+
+    public static void testPop(Queue<Integer> heap) {
+        int val = heap.poll(); // Извлечение элемента с вершины кучи
+        System.out.format("\nПосле удаления элемента %d с вершины кучи\n", val);
+        PrintUtil.printHeap(heap);
+    }
+
+    public static void main(String[] args) {
+        /* Инициализация кучи */
+        // Инициализация минимальной кучи
+        Queue<Integer> minHeap = new PriorityQueue<>();
+        // Инициализация максимальной кучи (достаточно изменить Comparator с помощью lambda-выражения)
+        Queue<Integer> maxHeap = new PriorityQueue<>((a, b) -> b - a);
+
+        System.out.println("\nНиже приведен тестовый пример для max-heap");
+
+        /* Добавление элемента в кучу */
+        testPush(maxHeap, 1);
+        testPush(maxHeap, 3);
+        testPush(maxHeap, 2);
+        testPush(maxHeap, 5);
+        testPush(maxHeap, 4);
+
+        /* Получение элемента с вершины кучи */
+        int peek = maxHeap.peek();
+        System.out.format("\nЭлемент на вершине кучи = %d\n", peek);
+
+        /* Извлечение элемента с вершины кучи */
+        testPop(maxHeap);
+        testPop(maxHeap);
+        testPop(maxHeap);
+        testPop(maxHeap);
+        testPop(maxHeap);
+
+        /* Получение размера кучи */
+        int size = maxHeap.size();
+        System.out.format("\nКоличество элементов в куче = %d\n", size);
+
+        /* Проверка, пуста ли куча */
+        boolean isEmpty = maxHeap.isEmpty();
+        System.out.format("\nПуста ли куча: %b\n", isEmpty);
+
+        /* Построить кучу по входному списку */
+        // Временная сложность равна O(n), а не O(nlogn)
+        minHeap = new PriorityQueue<>(Arrays.asList(1, 3, 2, 5, 4));
+        System.out.println("\nПосле построения min-heap из входного списка");
+        PrintUtil.printHeap(minHeap);
+    }
+}

ru/codes/java/chapter_heap/my_heap.java

@@ -0,0 +1,159 @@
+/**
+ * File: my_heap.java
+ * Created Time: 2023-01-07
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_heap;
+
+import utils.*;
+import java.util.*;
+
+/* Максимальная куча */
+class MaxHeap {
+    // Использовать список вместо массива, чтобы не учитывать проблему расширения
+    private List<Integer> maxHeap;
+
+    /* Конструктор, строящий кучу по входному списку */
+    public MaxHeap(List<Integer> nums) {
+        // Добавить элементы списка в кучу без изменений
+        maxHeap = new ArrayList<>(nums);
+        // Выполнить heapify для всех узлов, кроме листовых
+        for (int i = parent(size() - 1); i >= 0; i--) {
+            siftDown(i);
+        }
+    }
+
+    /* Получить индекс левого дочернего узла */
+    private int left(int i) {
+        return 2 * i + 1;
+    }
+
+    /* Получить индекс правого дочернего узла */
+    private int right(int i) {
+        return 2 * i + 2;
+    }
+
+    /* Получить индекс родительского узла */
+    private int parent(int i) {
+        return (i - 1) / 2; // Округление вниз при делении
+    }
+
+    /* Поменять элементы местами */
+    private void swap(int i, int j) {
+        int tmp = maxHeap.get(i);
+        maxHeap.set(i, maxHeap.get(j));
+        maxHeap.set(j, tmp);
+    }
+
+    /* Получение размера кучи */
+    public int size() {
+        return maxHeap.size();
+    }
+
+    /* Проверка, пуста ли куча */
+    public boolean isEmpty() {
+        return size() == 0;
+    }
+
+    /* Доступ к элементу на вершине кучи */
+    public int peek() {
+        return maxHeap.get(0);
+    }
+
+    /* Добавление элемента в кучу */
+    public void push(int val) {
+        // Добавление узла
+        maxHeap.add(val);
+        // Просеивание снизу вверх
+        siftUp(size() - 1);
+    }
+
+    /* Начиная с узла i, выполнить просеивание снизу вверх */
+    private void siftUp(int i) {
+        while (true) {
+            // Получение родительского узла для узла i
+            int p = parent(i);
+            // Завершить heapify, когда «корневой узел уже пройден» или «узел не требует исправления»
+            if (p < 0 || maxHeap.get(i) <= maxHeap.get(p))
+                break;
+            // Поменять два узла местами
+            swap(i, p);
+            // Циклическое просеивание вверх
+            i = p;
+        }
+    }
+
+    /* Извлечение элемента из кучи */
+    public int pop() {
+        // Обработка пустого случая
+        if (isEmpty())
+            throw new IndexOutOfBoundsException();
+        // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)
+        swap(0, size() - 1);
+        // Удаление узла
+        int val = maxHeap.remove(size() - 1);
+        // Просеивание сверху вниз
+        siftDown(0);
+        // Вернуть элемент с вершины кучи
+        return val;
+    }
+
+    /* Начиная с узла i, выполнить просеивание сверху вниз */
+    private void siftDown(int i) {
+        while (true) {
+            // Определить узел с максимальным значением среди i, l и r и обозначить его как ma
+            int l = left(i), r = right(i), ma = i;
+            if (l < size() && maxHeap.get(l) > maxHeap.get(ma))
+                ma = l;
+            if (r < size() && maxHeap.get(r) > maxHeap.get(ma))
+                ma = r;
+            // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти
+            if (ma == i)
+                break;
+            // Поменять два узла местами
+            swap(i, ma);
+            // Циклическое просеивание вниз
+            i = ma;
+        }
+    }
+
+    /* Вывести кучу (двоичное дерево) */
+    public void print() {
+        Queue<Integer> queue = new PriorityQueue<>((a, b) -> { return b - a; });
+        queue.addAll(maxHeap);
+        PrintUtil.printHeap(queue);
+    }
+}
+
+public class my_heap {
+    public static void main(String[] args) {
+        /* Инициализация максимальной кучи */
+        MaxHeap maxHeap = new MaxHeap(Arrays.asList(9, 8, 6, 6, 7, 5, 2, 1, 4, 3, 6, 2));
+        System.out.println("\nПосле построения кучи из входного списка");
+        maxHeap.print();
+
+        /* Получение элемента с вершины кучи */
+        int peek = maxHeap.peek();
+        System.out.format("\nЭлемент на вершине кучи = %d\n", peek);
+
+        /* Добавление элемента в кучу */
+        int val = 7;
+        maxHeap.push(val);
+        System.out.format("\nПосле добавления элемента %d в кучу\n", val);
+        maxHeap.print();
+
+        /* Извлечение элемента с вершины кучи */
+        peek = maxHeap.pop();
+        System.out.format("\nПосле удаления элемента %d с вершины кучи\n", peek);
+        maxHeap.print();
+
+        /* Получение размера кучи */
+        int size = maxHeap.size();
+        System.out.format("\nКоличество элементов в куче = %d\n", size);
+
+        /* Проверка, пуста ли куча */
+        boolean isEmpty = maxHeap.isEmpty();
+        System.out.format("\nПуста ли куча: %b\n", isEmpty);
+    }
+}

ru/codes/java/chapter_heap/top_k.java

@@ -0,0 +1,40 @@
+/**
+ * File: top_k.java
+ * Created Time: 2023-06-12
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_heap;
+
+import utils.*;
+import java.util.*;
+
+public class top_k {
+    /* Найти k наибольших элементов массива с помощью кучи */
+    static Queue<Integer> topKHeap(int[] nums, int k) {
+        // Инициализация минимальной кучи
+        Queue<Integer> heap = new PriorityQueue<Integer>();
+        // Поместить первые k элементов массива в кучу
+        for (int i = 0; i < k; i++) {
+            heap.offer(nums[i]);
+        }
+        // Начиная с элемента k+1, поддерживать длину кучи равной k
+        for (int i = k; i < nums.length; i++) {
+            // Если текущий элемент больше элемента на вершине кучи, извлечь вершину кучи и добавить текущий элемент в кучу
+            if (nums[i] > heap.peek()) {
+                heap.poll();
+                heap.offer(nums[i]);
+            }
+        }
+        return heap;
+    }
+
+    public static void main(String[] args) {
+        int[] nums = { 1, 7, 6, 3, 2 };
+        int k = 3;
+
+        Queue<Integer> res = topKHeap(nums, k);
+        System.out.println("Наибольшие " + k + " элементов");
+        PrintUtil.printHeap(res);
+    }
+}

ru/codes/java/chapter_searching/binary_search.java

@@ -0,0 +1,58 @@
+/**
+ * File: binary_search.java
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_searching;
+
+public class binary_search {
+    /* Бинарный поиск (двусторонне замкнутый интервал) */
+    static int binarySearch(int[] nums, int target) {
+        // Инициализировать двусторонне замкнутый интервал [0, n-1], то есть i и j указывают на первый и последний элементы массива соответственно
+        int i = 0, j = nums.length - 1;
+        // Цикл завершается, когда диапазон поиска пуст (при i > j диапазон пуст)
+        while (i <= j) {
+            int m = i + (j - i) / 2; // Вычислить индекс середины m
+            if (nums[m] < target) // Это означает, что target находится в интервале [m+1, j]
+                i = m + 1;
+            else if (nums[m] > target) // Это означает, что target находится в интервале [i, m-1]
+                j = m - 1;
+            else // Целевой элемент найден, вернуть его индекс
+                return m;
+        }
+        // Целевой элемент не найден, вернуть -1
+        return -1;
+    }
+
+    /* Бинарный поиск (лево замкнутый, право открытый интервал) */
+    static int binarySearchLCRO(int[] nums, int target) {
+        // Инициализировать лево замкнутый, право открытый интервал [0, n), то есть i и j указывают на первый элемент массива и позицию сразу за последним элементом соответственно
+        int i = 0, j = nums.length;
+        // Цикл завершается, когда диапазон поиска пуст (при i = j диапазон пуст)
+        while (i < j) {
+            int m = i + (j - i) / 2; // Вычислить индекс середины m
+            if (nums[m] < target) // Это означает, что target находится в интервале [m+1, j)
+                i = m + 1;
+            else if (nums[m] > target) // Это означает, что target находится в интервале [i, m)
+                j = m;
+            else // Целевой элемент найден, вернуть его индекс
+                return m;
+        }
+        // Целевой элемент не найден, вернуть -1
+        return -1;
+    }
+
+    public static void main(String[] args) {
+        int target = 6;
+        int[] nums = { 1, 3, 6, 8, 12, 15, 23, 26, 31, 35 };
+
+        /* Бинарный поиск (двусторонне замкнутый интервал) */
+        int index = binarySearch(nums, target);
+        System.out.println("Индекс целевого элемента 6 = " + index);
+
+        /* Бинарный поиск (лево замкнутый, право открытый интервал) */
+        index = binarySearchLCRO(nums, target);
+        System.out.println("Индекс целевого элемента 6 = " + index);
+    }
+}

ru/codes/java/chapter_searching/binary_search_edge.java

@@ -0,0 +1,49 @@
+/**
+ * File: binary_search_edge.java
+ * Created Time: 2023-08-04
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_searching;
+
+public class binary_search_edge {
+    /* Бинарный поиск самого левого target */
+    static int binarySearchLeftEdge(int[] nums, int target) {
+        // Эквивалентно поиску точки вставки target
+        int i = binary_search_insertion.binarySearchInsertion(nums, target);
+        // target не найден, вернуть -1
+        if (i == nums.length || nums[i] != target) {
+            return -1;
+        }
+        // Найти target и вернуть индекс i
+        return i;
+    }
+
+    /* Бинарный поиск самого правого target */
+    static int binarySearchRightEdge(int[] nums, int target) {
+        // Преобразовать задачу в поиск самого левого target + 1
+        int i = binary_search_insertion.binarySearchInsertion(nums, target + 1);
+        // j указывает на самый правый target, а i — на первый элемент больше target
+        int j = i - 1;
+        // target не найден, вернуть -1
+        if (j == -1 || nums[j] != target) {
+            return -1;
+        }
+        // Найти target и вернуть индекс j
+        return j;
+    }
+
+    public static void main(String[] args) {
+        // Массив с повторяющимися элементами
+        int[] nums = { 1, 3, 6, 6, 6, 6, 6, 10, 12, 15 };
+        System.out.println("\nМассив nums = " + java.util.Arrays.toString(nums));
+
+        // Бинарный поиск левой и правой границы
+        for (int target : new int[] { 6, 7 }) {
+            int index = binarySearchLeftEdge(nums, target);
+            System.out.println("Индекс самого левого элемента " + target + " равен " + index);
+            index = binarySearchRightEdge(nums, target);
+            System.out.println("Индекс самого правого элемента " + target + " равен " + index);
+        }
+    }
+}

ru/codes/java/chapter_searching/binary_search_insertion.java

@@ -0,0 +1,63 @@
+/**
+ * File: binary_search_insertion.java
+ * Created Time: 2023-08-04
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_searching;
+
+class binary_search_insertion {
+    /* Бинарный поиск точки вставки (без повторяющихся элементов) */
+    static int binarySearchInsertionSimple(int[] nums, int target) {
+        int i = 0, j = nums.length - 1; // Инициализировать двусторонне замкнутый интервал [0, n-1]
+        while (i <= j) {
+            int m = i + (j - i) / 2; // Вычислить индекс середины m
+            if (nums[m] < target) {
+                i = m + 1; // target находится в интервале [m+1, j]
+            } else if (nums[m] > target) {
+                j = m - 1; // target находится в интервале [i, m-1]
+            } else {
+                return m; // Найти target и вернуть точку вставки m
+            }
+        }
+        // target не найден, вернуть точку вставки i
+        return i;
+    }
+
+    /* Бинарный поиск точки вставки (с повторяющимися элементами) */
+    static int binarySearchInsertion(int[] nums, int target) {
+        int i = 0, j = nums.length - 1; // Инициализировать двусторонне замкнутый интервал [0, n-1]
+        while (i <= j) {
+            int m = i + (j - i) / 2; // Вычислить индекс середины m
+            if (nums[m] < target) {
+                i = m + 1; // target находится в интервале [m+1, j]
+            } else if (nums[m] > target) {
+                j = m - 1; // target находится в интервале [i, m-1]
+            } else {
+                j = m - 1; // Первый элемент меньше target находится в интервале [i, m-1]
+            }
+        }
+        // Вернуть точку вставки i
+        return i;
+    }
+
+    public static void main(String[] args) {
+        // Массив без повторяющихся элементов
+        int[] nums = { 1, 3, 6, 8, 12, 15, 23, 26, 31, 35 };
+        System.out.println("\nМассив nums = " + java.util.Arrays.toString(nums));
+        // Бинарный поиск точки вставки
+        for (int target : new int[] { 6, 9 }) {
+            int index = binarySearchInsertionSimple(nums, target);
+            System.out.println("Индекс позиции вставки элемента " + target + " равен " + index);
+        }
+
+        // Массив с повторяющимися элементами
+        nums = new int[] { 1, 3, 6, 6, 6, 6, 6, 10, 12, 15 };
+        System.out.println("\nМассив nums = " + java.util.Arrays.toString(nums));
+        // Бинарный поиск точки вставки
+        for (int target : new int[] { 2, 6, 20 }) {
+            int index = binarySearchInsertion(nums, target);
+            System.out.println("Индекс позиции вставки элемента " + target + " равен " + index);
+        }
+    }
+}

ru/codes/java/chapter_searching/hashing_search.java

@@ -0,0 +1,51 @@
+/**
+ * File: hashing_search.java
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_searching;
+
+import utils.*;
+import java.util.*;
+
+public class hashing_search {
+    /* Хеш-поиск (массив) */
+    static int hashingSearchArray(Map<Integer, Integer> map, int target) {
+        // key хеш-таблицы: целевой элемент, value: индекс
+        // Если такого key нет в хеш-таблице, вернуть -1
+        return map.getOrDefault(target, -1);
+    }
+
+    /* Хеш-поиск (связный список) */
+    static ListNode hashingSearchLinkedList(Map<Integer, ListNode> map, int target) {
+        // key хеш-таблицы: значение целевого узла, value: объект узла
+        // Если такого key нет в хеш-таблице, вернуть null
+        return map.getOrDefault(target, null);
+    }
+
+    public static void main(String[] args) {
+        int target = 3;
+
+        /* Хеш-поиск (массив) */
+        int[] nums = { 1, 5, 3, 2, 4, 7, 5, 9, 10, 8 };
+        // Инициализация хеш-таблицы
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int i = 0; i < nums.length; i++) {
+            map.put(nums[i], i); // key: элемент, value: индекс
+        }
+        int index = hashingSearchArray(map, target);
+        System.out.println("Индекс целевого элемента 3 = " + index);
+
+        /* Хеш-поиск (связный список) */
+        ListNode head = ListNode.arrToLinkedList(nums);
+        // Инициализация хеш-таблицы
+        Map<Integer, ListNode> map1 = new HashMap<>();
+        while (head != null) {
+            map1.put(head.val, head); // key: значение узла, value: узел
+            head = head.next;
+        }
+        ListNode node = hashingSearchLinkedList(map1, target);
+        System.out.println("Объект узла со значением 3 = " + node);
+    }
+}

ru/codes/java/chapter_searching/linear_search.java

@@ -0,0 +1,50 @@
+/**
+ * File: linear_search.java
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_searching;
+
+import utils.*;
+
+public class linear_search {
+    /* Линейный поиск (массив) */
+    static int linearSearchArray(int[] nums, int target) {
+        // Обход массива
+        for (int i = 0; i < nums.length; i++) {
+            // Целевой элемент найден, вернуть его индекс
+            if (nums[i] == target)
+                return i;
+        }
+        // Целевой элемент не найден, вернуть -1
+        return -1;
+    }
+
+    /* Линейный поиск (связный список) */
+    static ListNode linearSearchLinkedList(ListNode head, int target) {
+        // Обойти связный список
+        while (head != null) {
+            // Найти целевой узел и вернуть его
+            if (head.val == target)
+                return head;
+            head = head.next;
+        }
+        // Целевой узел не найден, вернуть null
+        return null;
+    }
+
+    public static void main(String[] args) {
+        int target = 3;
+
+        /* Выполнить линейный поиск в массиве */
+        int[] nums = { 1, 5, 3, 2, 4, 7, 5, 9, 10, 8 };
+        int index = linearSearchArray(nums, target);
+        System.out.println("Индекс целевого элемента 3 = " + index);
+
+        /* Выполнить линейный поиск в связном списке */
+        ListNode head = ListNode.arrToLinkedList(nums);
+        ListNode node = linearSearchLinkedList(head, target);
+        System.out.println("Объект узла со значением 3 = " + node);
+    }
+}

ru/codes/java/chapter_searching/two_sum.java

@@ -0,0 +1,53 @@
+/**
+ * File: two_sum.java
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_searching;
+
+import java.util.*;
+
+public class two_sum {
+    /* Метод 1: полный перебор */
+    static int[] twoSumBruteForce(int[] nums, int target) {
+        int size = nums.length;
+        // Два вложенных цикла, временная сложность O(n^2)
+        for (int i = 0; i < size - 1; i++) {
+            for (int j = i + 1; j < size; j++) {
+                if (nums[i] + nums[j] == target)
+                    return new int[] { i, j };
+            }
+        }
+        return new int[0];
+    }
+
+    /* Метод 2: вспомогательная хеш-таблица */
+    static int[] twoSumHashTable(int[] nums, int target) {
+        int size = nums.length;
+        // Вспомогательная хеш-таблица, пространственная сложность O(n)
+        Map<Integer, Integer> dic = new HashMap<>();
+        // Один цикл, временная сложность O(n)
+        for (int i = 0; i < size; i++) {
+            if (dic.containsKey(target - nums[i])) {
+                return new int[] { dic.get(target - nums[i]), i };
+            }
+            dic.put(nums[i], i);
+        }
+        return new int[0];
+    }
+
+    public static void main(String[] args) {
+        // ======= Test Case =======
+        int[] nums = { 2, 7, 11, 15 };
+        int target = 13;
+
+        // ====== Основной код ======
+        // Метод 1
+        int[] res = twoSumBruteForce(nums, target);
+        System.out.println("Результат метода 1 res = " + Arrays.toString(res));
+        // Метод 2
+        res = twoSumHashTable(nums, target);
+        System.out.println("Результат метода 2 res = " + Arrays.toString(res));
+    }
+}

ru/codes/java/chapter_sorting/bubble_sort.java

@@ -0,0 +1,57 @@
+/**
+ * File: bubble_sort.java
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_sorting;
+
+import java.util.*;
+
+public class bubble_sort {
+    /* Пузырьковая сортировка */
+    static void bubbleSort(int[] nums) {
+        // Внешний цикл: неотсортированный диапазон [0, i]
+        for (int i = nums.length - 1; i > 0; i--) {
+            // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
+            for (int j = 0; j < i; j++) {
+                if (nums[j] > nums[j + 1]) {
+                    // Поменять местами nums[j] и nums[j + 1]
+                    int tmp = nums[j];
+                    nums[j] = nums[j + 1];
+                    nums[j + 1] = tmp;
+                }
+            }
+        }
+    }
+
+    /* Пузырьковая сортировка (оптимизация флагом) */
+    static void bubbleSortWithFlag(int[] nums) {
+        // Внешний цикл: неотсортированный диапазон [0, i]
+        for (int i = nums.length - 1; i > 0; i--) {
+            boolean flag = false; // Инициализировать флаг
+            // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
+            for (int j = 0; j < i; j++) {
+                if (nums[j] > nums[j + 1]) {
+                    // Поменять местами nums[j] и nums[j + 1]
+                    int tmp = nums[j];
+                    nums[j] = nums[j + 1];
+                    nums[j + 1] = tmp;
+                    flag = true; // Записать обмен элементов
+                }
+            }
+            if (!flag)
+                break; // На этой итерации «всплытия» не было ни одного обмена, сразу выйти
+        }
+    }
+
+    public static void main(String[] args) {
+        int[] nums = { 4, 1, 3, 1, 5, 2 };
+        bubbleSort(nums);
+        System.out.println("После пузырьковой сортировки nums = " + Arrays.toString(nums));
+
+        int[] nums1 = { 4, 1, 3, 1, 5, 2 };
+        bubbleSortWithFlag(nums1);
+        System.out.println("После пузырьковой сортировки nums1 = " + Arrays.toString(nums1));
+    }
+}

ru/codes/java/chapter_sorting/bucket_sort.java

@@ -0,0 +1,47 @@
+/**
+ * File: bucket_sort.java
+ * Created Time: 2023-03-17
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_sorting;
+
+import java.util.*;
+
+public class bucket_sort {
+    /* Сортировка корзинами */
+    static void bucketSort(float[] nums) {
+        // Инициализировать k = n/2 корзин, предполагая распределение 2 элементов в каждую корзину
+        int k = nums.length / 2;
+        List<List<Float>> buckets = new ArrayList<>();
+        for (int i = 0; i < k; i++) {
+            buckets.add(new ArrayList<>());
+        }
+        // 1. Распределить элементы массива по корзинам
+        for (float num : nums) {
+            // Входные данные лежат в диапазоне [0, 1); использовать num * k для отображения в диапазон индексов [0, k-1]
+            int i = (int) (num * k);
+            // Добавить num в корзину i
+            buckets.get(i).add(num);
+        }
+        // 2. Выполнить сортировку внутри каждой корзины
+        for (List<Float> bucket : buckets) {
+            // Использовать встроенную функцию сортировки; ее также можно заменить другим алгоритмом сортировки
+            Collections.sort(bucket);
+        }
+        // 3. Обойти корзины и объединить результаты
+        int i = 0;
+        for (List<Float> bucket : buckets) {
+            for (float num : bucket) {
+                nums[i++] = num;
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        // Пусть входные данные — числа с плавающей точкой из диапазона [0, 1)
+        float[] nums = { 0.49f, 0.96f, 0.82f, 0.09f, 0.57f, 0.43f, 0.91f, 0.75f, 0.15f, 0.37f };
+        bucketSort(nums);
+        System.out.println("После сортировки корзинами nums = " + Arrays.toString(nums));
+    }
+}

ru/codes/java/chapter_sorting/counting_sort.java

@@ -0,0 +1,78 @@
+/**
+ * File: counting_sort.java
+ * Created Time: 2023-03-17
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_sorting;
+
+import java.util.*;
+
+public class counting_sort {
+    /* Сортировка подсчетом */
+    // Простая реализация, не подходит для сортировки объектов
+    static void countingSortNaive(int[] nums) {
+        // 1. Найти максимальный элемент массива m
+        int m = 0;
+        for (int num : nums) {
+            m = Math.max(m, num);
+        }
+        // 2. Подсчитать число появлений каждой цифры
+        // counter[num] обозначает число появлений num
+        int[] counter = new int[m + 1];
+        for (int num : nums) {
+            counter[num]++;
+        }
+        // 3. Обойти counter и заполнить исходный массив nums элементами
+        int i = 0;
+        for (int num = 0; num < m + 1; num++) {
+            for (int j = 0; j < counter[num]; j++, i++) {
+                nums[i] = num;
+            }
+        }
+    }
+
+    /* Сортировка подсчетом */
+    // Полная реализация, позволяет сортировать объекты и является стабильной сортировкой
+    static void countingSort(int[] nums) {
+        // 1. Найти максимальный элемент массива m
+        int m = 0;
+        for (int num : nums) {
+            m = Math.max(m, num);
+        }
+        // 2. Подсчитать число появлений каждой цифры
+        // counter[num] обозначает число появлений num
+        int[] counter = new int[m + 1];
+        for (int num : nums) {
+            counter[num]++;
+        }
+        // 3. Вычислить префиксные суммы counter и преобразовать «число появлений» в «конечный индекс»
+        // То есть counter[num]-1 — это индекс последнего появления num в res
+        for (int i = 0; i < m; i++) {
+            counter[i + 1] += counter[i];
+        }
+        // 4. Обойти nums в обратном порядке и поместить элементы в результирующий массив res
+        // Инициализировать массив res для хранения результата
+        int n = nums.length;
+        int[] res = new int[n];
+        for (int i = n - 1; i >= 0; i--) {
+            int num = nums[i];
+            res[counter[num] - 1] = num; // Поместить num по соответствующему индексу
+            counter[num]--; // Уменьшить префиксную сумму на 1, чтобы получить индекс следующего размещения num
+        }
+        // Перезаписать исходный массив nums массивом результата res
+        for (int i = 0; i < n; i++) {
+            nums[i] = res[i];
+        }
+    }
+
+    public static void main(String[] args) {
+        int[] nums = { 1, 0, 1, 2, 0, 4, 0, 2, 2, 4 };
+        countingSortNaive(nums);
+        System.out.println("После сортировки подсчетом (объекты не поддерживаются) nums = " + Arrays.toString(nums));
+
+        int[] nums1 = { 1, 0, 1, 2, 0, 4, 0, 2, 2, 4 };
+        countingSort(nums1);
+        System.out.println("После сортировки подсчетом nums1 = " + Arrays.toString(nums1));
+    }
+}

ru/codes/java/chapter_sorting/heap_sort.java

@@ -0,0 +1,57 @@
+/**
+ * File: heap_sort.java
+ * Created Time: 2023-05-26
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_sorting;
+
+import java.util.Arrays;
+
+public class heap_sort {
+    /* Длина кучи равна n; начиная с узла i, выполнить просеивание сверху вниз */
+    public static void siftDown(int[] nums, int n, int i) {
+        while (true) {
+            // Определить узел с максимальным значением среди i, l и r и обозначить его как ma
+            int l = 2 * i + 1;
+            int r = 2 * i + 2;
+            int ma = i;
+            if (l < n && nums[l] > nums[ma])
+                ma = l;
+            if (r < n && nums[r] > nums[ma])
+                ma = r;
+            // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти
+            if (ma == i)
+                break;
+            // Поменять два узла местами
+            int temp = nums[i];
+            nums[i] = nums[ma];
+            nums[ma] = temp;
+            // Циклическое просеивание вниз
+            i = ma;
+        }
+    }
+
+    /* Сортировка кучей */
+    public static void heapSort(int[] nums) {
+        // Построение кучи: выполнить heapify для всех узлов, кроме листовых
+        for (int i = nums.length / 2 - 1; i >= 0; i--) {
+            siftDown(nums, nums.length, i);
+        }
+        // Извлекать максимальный элемент из кучи в течение n-1 итераций
+        for (int i = nums.length - 1; i > 0; i--) {
+            // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)
+            int tmp = nums[0];
+            nums[0] = nums[i];
+            nums[i] = tmp;
+            // Начиная с корневого узла, выполнить просеивание сверху вниз
+            siftDown(nums, i, 0);
+        }
+    }
+
+    public static void main(String[] args) {
+        int[] nums = { 4, 1, 3, 1, 5, 2 };
+        heapSort(nums);
+        System.out.println("После сортировки кучей nums = " + Arrays.toString(nums));
+    }
+}

ru/codes/java/chapter_sorting/insertion_sort.java

@@ -0,0 +1,31 @@
+/**
+ * File: insertion_sort.java
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_sorting;
+
+import java.util.*;
+
+public class insertion_sort {
+    /* Сортировка вставками */
+    static void insertionSort(int[] nums) {
+        // Внешний цикл: отсортированный диапазон [0, i-1]
+        for (int i = 1; i < nums.length; i++) {
+            int base = nums[i], j = i - 1;
+            // Внутренний цикл: вставить base в правильную позицию отсортированного диапазона [0, i-1]
+            while (j >= 0 && nums[j] > base) {
+                nums[j + 1] = nums[j]; // Сдвинуть nums[j] на одну позицию вправо
+                j--;
+            }
+            nums[j + 1] = base;        // Поместить base в правильную позицию
+        }
+    }
+
+    public static void main(String[] args) {
+        int[] nums = { 4, 1, 3, 1, 5, 2 };
+        insertionSort(nums);
+        System.out.println("После сортировки вставками nums = " + Arrays.toString(nums));
+    }
+}

ru/codes/java/chapter_sorting/merge_sort.java

@@ -0,0 +1,58 @@
+/**
+ * File: merge_sort.java
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_sorting;
+
+import java.util.*;
+
+public class merge_sort {
+    /* Объединить левый и правый подмассивы */
+    static void merge(int[] nums, int left, int mid, int right) {
+        // Диапазон левого подмассива: [left, mid], диапазон правого подмассива: [mid+1, right]
+        // Создать временный массив tmp для хранения результата слияния
+        int[] tmp = new int[right - left + 1];
+        // Инициализировать начальные индексы левого и правого подмассивов
+        int i = left, j = mid + 1, k = 0;
+        // Пока в левом и правом подмассивах еще есть элементы, сравнивать их и копировать меньший во временный массив
+        while (i <= mid && j <= right) {
+            if (nums[i] <= nums[j])
+                tmp[k++] = nums[i++];
+            else
+                tmp[k++] = nums[j++];
+        }
+        // Скопировать оставшиеся элементы левого и правого подмассивов во временный массив
+        while (i <= mid) {
+            tmp[k++] = nums[i++];
+        }
+        while (j <= right) {
+            tmp[k++] = nums[j++];
+        }
+        // Скопировать элементы временного массива tmp обратно в соответствующий диапазон исходного массива nums
+        for (k = 0; k < tmp.length; k++) {
+            nums[left + k] = tmp[k];
+        }
+    }
+
+    /* Сортировка слиянием */
+    static void mergeSort(int[] nums, int left, int right) {
+        // Условие завершения
+        if (left >= right)
+            return; // Завершить рекурсию, когда длина подмассива равна 1
+        // Этап разбиения
+        int mid = left + (right - left) / 2; // Вычислить середину
+        mergeSort(nums, left, mid); // Рекурсивно обработать левый подмассив
+        mergeSort(nums, mid + 1, right); // Рекурсивно обработать правый подмассив
+        // Этап слияния
+        merge(nums, left, mid, right);
+    }
+
+    public static void main(String[] args) {
+        /* Сортировка слиянием */
+        int[] nums = { 7, 3, 2, 6, 0, 1, 5, 4 };
+        mergeSort(nums, 0, nums.length - 1);
+        System.out.println("После сортировки слиянием nums = " + Arrays.toString(nums));
+    }
+}

ru/codes/java/chapter_sorting/quick_sort.java

@@ -0,0 +1,158 @@
+/**
+ * File: quick_sort.java
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_sorting;
+
+import java.util.*;
+
+/* Класс быстрой сортировки */
+class QuickSort {
+    /* Обмен элементов */
+    static void swap(int[] nums, int i, int j) {
+        int tmp = nums[i];
+        nums[i] = nums[j];
+        nums[j] = tmp;
+    }
+
+    /* Разбиение с опорными указателями */
+    static int partition(int[] nums, int left, int right) {
+        // Взять nums[left] в качестве опорного элемента
+        int i = left, j = right;
+        while (i < j) {
+            while (i < j && nums[j] >= nums[left])
+                j--;          // Идти справа налево в поисках первого элемента меньше опорного
+            while (i < j && nums[i] <= nums[left])
+                i++;          // Идти слева направо в поисках первого элемента больше опорного
+            swap(nums, i, j); // Поменять эти два элемента местами
+        }
+        swap(nums, i, left);  // Переместить опорный элемент на границу двух подмассивов
+        return i;             // Вернуть индекс опорного элемента
+    }
+
+    /* Быстрая сортировка */
+    public static void quickSort(int[] nums, int left, int right) {
+        // Завершить рекурсию, когда длина подмассива равна 1
+        if (left >= right)
+            return;
+        // Разбиение с опорными указателями
+        int pivot = partition(nums, left, right);
+        // Рекурсивно обработать левый и правый подмассивы
+        quickSort(nums, left, pivot - 1);
+        quickSort(nums, pivot + 1, right);
+    }
+}
+
+/* Класс быстрой сортировки (оптимизация медианным опорным элементом) */
+class QuickSortMedian {
+    /* Обмен элементов */
+    static void swap(int[] nums, int i, int j) {
+        int tmp = nums[i];
+        nums[i] = nums[j];
+        nums[j] = tmp;
+    }
+
+    /* Выбрать медиану из трех кандидатов */
+    static int medianThree(int[] nums, int left, int mid, int right) {
+        int l = nums[left], m = nums[mid], r = nums[right];
+        if ((l <= m && m <= r) || (r <= m && m <= l))
+            return mid; // m находится между l и r
+        if ((m <= l && l <= r) || (r <= l && l <= m))
+            return left; // l находится между m и r
+        return right;
+    }
+
+    /* Разбиение с опорными указателями (медиана трех) */
+    static int partition(int[] nums, int left, int right) {
+        // Выбрать медиану из трех кандидатов
+        int med = medianThree(nums, left, (left + right) / 2, right);
+        // Переместить медиану в крайний левый элемент массива
+        swap(nums, left, med);
+        // Взять nums[left] в качестве опорного элемента
+        int i = left, j = right;
+        while (i < j) {
+            while (i < j && nums[j] >= nums[left])
+                j--;          // Идти справа налево в поисках первого элемента меньше опорного
+            while (i < j && nums[i] <= nums[left])
+                i++;          // Идти слева направо в поисках первого элемента больше опорного
+            swap(nums, i, j); // Поменять эти два элемента местами
+        }
+        swap(nums, i, left);  // Переместить опорный элемент на границу двух подмассивов
+        return i;             // Вернуть индекс опорного элемента
+    }
+
+    /* Быстрая сортировка */
+    public static void quickSort(int[] nums, int left, int right) {
+        // Завершить рекурсию, когда длина подмассива равна 1
+        if (left >= right)
+            return;
+        // Разбиение с опорными указателями
+        int pivot = partition(nums, left, right);
+        // Рекурсивно обработать левый и правый подмассивы
+        quickSort(nums, left, pivot - 1);
+        quickSort(nums, pivot + 1, right);
+    }
+}
+
+/* Класс быстрой сортировки (оптимизация глубины рекурсии) */
+class QuickSortTailCall {
+    /* Обмен элементов */
+    static void swap(int[] nums, int i, int j) {
+        int tmp = nums[i];
+        nums[i] = nums[j];
+        nums[j] = tmp;
+    }
+
+    /* Разбиение с опорными указателями */
+    static int partition(int[] nums, int left, int right) {
+        // Взять nums[left] в качестве опорного элемента
+        int i = left, j = right;
+        while (i < j) {
+            while (i < j && nums[j] >= nums[left])
+                j--;          // Идти справа налево в поисках первого элемента меньше опорного
+            while (i < j && nums[i] <= nums[left])
+                i++;          // Идти слева направо в поисках первого элемента больше опорного
+            swap(nums, i, j); // Поменять эти два элемента местами
+        }
+        swap(nums, i, left);  // Переместить опорный элемент на границу двух подмассивов
+        return i;             // Вернуть индекс опорного элемента
+    }
+
+    /* Быстрая сортировка (оптимизация глубины рекурсии) */
+    public static void quickSort(int[] nums, int left, int right) {
+        // Завершить, когда длина подмассива равна 1
+        while (left < right) {
+            // Операция разбиения с опорными указателями
+            int pivot = partition(nums, left, right);
+            // Выполнить быструю сортировку для более короткого из двух подмассивов
+            if (pivot - left < right - pivot) {
+                quickSort(nums, left, pivot - 1); // Рекурсивно отсортировать левый подмассив
+                left = pivot + 1; // Оставшийся неотсортированный диапазон: [pivot + 1, right]
+            } else {
+                quickSort(nums, pivot + 1, right); // Рекурсивно отсортировать правый подмассив
+                right = pivot - 1; // Оставшийся неотсортированный диапазон: [left, pivot - 1]
+            }
+        }
+    }
+}
+
+public class quick_sort {
+    public static void main(String[] args) {
+        /* Быстрая сортировка */
+        int[] nums = { 2, 4, 1, 0, 3, 5 };
+        QuickSort.quickSort(nums, 0, nums.length - 1);
+        System.out.println("После быстрой сортировки nums = " + Arrays.toString(nums));
+
+        /* Быстрая сортировка (оптимизация медианным опорным элементом) */
+        int[] nums1 = { 2, 4, 1, 0, 3, 5 };
+        QuickSortMedian.quickSort(nums1, 0, nums1.length - 1);
+        System.out.println("После быстрой сортировки (оптимизация медианным опорным элементом) nums1 = " + Arrays.toString(nums1));
+
+        /* Быстрая сортировка (оптимизация глубины рекурсии) */
+        int[] nums2 = { 2, 4, 1, 0, 3, 5 };
+        QuickSortTailCall.quickSort(nums2, 0, nums2.length - 1);
+        System.out.println("После быстрой сортировки (оптимизация глубины рекурсии) nums2 = " + Arrays.toString(nums2));
+    }
+}

ru/codes/java/chapter_sorting/radix_sort.java

@@ -0,0 +1,69 @@
+/**
+ * File: radix_sort.java
+ * Created Time: 2023-01-17
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_sorting;
+
+import java.util.*;
+
+public class radix_sort {
+    /* Получить k-й разряд элемента num, где exp = 10^(k-1) */
+    static int digit(int num, int exp) {
+        // Передача exp вместо k позволяет избежать повторного дорогостоящего вычисления степени
+        return (num / exp) % 10;
+    }
+
+    /* Сортировка подсчетом (сортировка по k-му разряду nums) */
+    static void countingSortDigit(int[] nums, int exp) {
+        // Разряды десятичной системы лежат в диапазоне 0~9, поэтому нужен массив корзин длины 10
+        int[] counter = new int[10];
+        int n = nums.length;
+        // Подсчитать число появлений каждой цифры от 0 до 9
+        for (int i = 0; i < n; i++) {
+            int d = digit(nums[i], exp); // Получить k-й разряд nums[i], обозначив его как d
+            counter[d]++;                // Подсчитать число появлений цифры d
+        }
+        // Вычислить префиксные суммы и преобразовать «число появлений» в «индекс массива»
+        for (int i = 1; i < 10; i++) {
+            counter[i] += counter[i - 1];
+        }
+        // Выполняя обратный проход, заполнить res элементами по статистике в корзинах
+        int[] res = new int[n];
+        for (int i = n - 1; i >= 0; i--) {
+            int d = digit(nums[i], exp);
+            int j = counter[d] - 1; // Получить индекс j цифры d в массиве
+            res[j] = nums[i];       // Поместить текущий элемент по индексу j
+            counter[d]--;           // Уменьшить количество d на 1
+        }
+        // Перезаписать исходный массив nums результатом
+        for (int i = 0; i < n; i++)
+            nums[i] = res[i];
+    }
+
+    /* Поразрядная сортировка */
+    static void radixSort(int[] nums) {
+        // Получить максимальный элемент массива, чтобы определить максимальное число разрядов
+        int m = Integer.MIN_VALUE;
+        for (int num : nums)
+            if (num > m)
+                m = num;
+        // Проходить разряды от младшего к старшему
+        for (int exp = 1; exp <= m; exp *= 10) {
+            // Выполнить сортировку подсчетом по k-му разряду элементов массива
+            // k = 1 -> exp = 1
+            // k = 2 -> exp = 10
+            // то есть exp = 10^(k-1)
+            countingSortDigit(nums, exp);
+        }
+    }
+
+    public static void main(String[] args) {
+        // Поразрядная сортировка
+        int[] nums = { 10546151, 35663510, 42865989, 34862445, 81883077,
+                       88906420, 72429244, 30524779, 82060337, 63832996 };
+        radixSort(nums);
+        System.out.println("После поразрядной сортировки nums = " + Arrays.toString(nums));
+    }
+}

ru/codes/java/chapter_sorting/selection_sort.java

@@ -0,0 +1,35 @@
+/**
+ * File: selection_sort.java
+ * Created Time: 2023-05-23
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_sorting;
+
+import java.util.Arrays;
+
+public class selection_sort {
+    /* Сортировка выбором */
+    public static void selectionSort(int[] nums) {
+        int n = nums.length;
+        // Внешний цикл: неотсортированный диапазон [i, n-1]
+        for (int i = 0; i < n - 1; i++) {
+            // Внутренний цикл: найти минимальный элемент в неотсортированном диапазоне
+            int k = i;
+            for (int j = i + 1; j < n; j++) {
+                if (nums[j] < nums[k])
+                    k = j; // Записать индекс минимального элемента
+            }
+            // Поменять этот минимальный элемент местами с первым элементом неотсортированного диапазона
+            int temp = nums[i];
+            nums[i] = nums[k];
+            nums[k] = temp;
+        }
+    }
+
+    public static void main(String[] args) {
+        int[] nums = { 4, 1, 3, 1, 5, 2 };
+        selectionSort(nums);
+        System.out.println("После сортировки выбором nums = " + Arrays.toString(nums));
+    }
+}

ru/codes/java/chapter_stack_and_queue/array_deque.java

@@ -0,0 +1,151 @@
+/**
+ * File: array_deque.java
+ * Created Time: 2023-02-16
+ * Author: krahets (krahets@163.com), FangYuan33 (374072213@qq.com)
+ */
+
+package chapter_stack_and_queue;
+
+import java.util.*;
+
+/* Двусторонняя очередь на основе кольцевого массива */
+class ArrayDeque {
+    private int[] nums; // Массив для хранения элементов двусторонней очереди
+    private int front; // Указатель head, указывающий на первый элемент очереди
+    private int queSize; // Длина двусторонней очереди
+
+    /* Конструктор */
+    public ArrayDeque(int capacity) {
+        this.nums = new int[capacity];
+        front = queSize = 0;
+    }
+
+    /* Получить вместимость двусторонней очереди */
+    public int capacity() {
+        return nums.length;
+    }
+
+    /* Получение длины двусторонней очереди */
+    public int size() {
+        return queSize;
+    }
+
+    /* Проверка, пуста ли двусторонняя очередь */
+    public boolean isEmpty() {
+        return queSize == 0;
+    }
+
+    /* Вычислить индекс в кольцевом массиве */
+    private int index(int i) {
+        // С помощью операции взятия по модулю соединить начало и конец массива
+        // Когда i выходит за конец массива, он возвращается в начало
+        // Когда i выходит за начало массива, он возвращается в конец
+        return (i + capacity()) % capacity();
+    }
+
+    /* Добавление в голову очереди */
+    public void pushFirst(int num) {
+        if (queSize == capacity()) {
+            System.out.println("Двусторонняя очередь заполнена");
+            return;
+        }
+        // Указатель головы сдвигается на одну позицию влево
+        // С помощью операции взятия по модулю front после выхода за начало массива возвращается в хвост
+        front = index(front - 1);
+        // Добавить num в голову очереди
+        nums[front] = num;
+        queSize++;
+    }
+
+    /* Добавление в хвост очереди */
+    public void pushLast(int num) {
+        if (queSize == capacity()) {
+            System.out.println("Двусторонняя очередь заполнена");
+            return;
+        }
+        // Вычислить указатель хвоста, указывающий на индекс хвоста + 1
+        int rear = index(front + queSize);
+        // Добавить num в хвост очереди
+        nums[rear] = num;
+        queSize++;
+    }
+
+    /* Извлечение из головы очереди */
+    public int popFirst() {
+        int num = peekFirst();
+        // Указатель головы сдвигается на одну позицию назад
+        front = index(front + 1);
+        queSize--;
+        return num;
+    }
+
+    /* Извлечение из хвоста очереди */
+    public int popLast() {
+        int num = peekLast();
+        queSize--;
+        return num;
+    }
+
+    /* Доступ к элементу в начале очереди */
+    public int peekFirst() {
+        if (isEmpty())
+            throw new IndexOutOfBoundsException();
+        return nums[front];
+    }
+
+    /* Доступ к элементу в конце очереди */
+    public int peekLast() {
+        if (isEmpty())
+            throw new IndexOutOfBoundsException();
+        // Вычислить индекс хвостового элемента
+        int last = index(front + queSize - 1);
+        return nums[last];
+    }
+
+    /* Вернуть массив для вывода */
+    public int[] toArray() {
+        // Преобразовывать только элементы списка в пределах фактической длины
+        int[] res = new int[queSize];
+        for (int i = 0, j = front; i < queSize; i++, j++) {
+            res[i] = nums[index(j)];
+        }
+        return res;
+    }
+}
+
+public class array_deque {
+    public static void main(String[] args) {
+        /* Инициализация двусторонней очереди */
+        ArrayDeque deque = new ArrayDeque(10);
+        deque.pushLast(3);
+        deque.pushLast(2);
+        deque.pushLast(5);
+        System.out.println("Двусторонняя очередь deque = " + Arrays.toString(deque.toArray()));
+
+        /* Доступ к элементу */
+        int peekFirst = deque.peekFirst();
+        System.out.println("Первый элемент peekFirst = " + peekFirst);
+        int peekLast = deque.peekLast();
+        System.out.println("Последний элемент peekLast = " + peekLast);
+
+        /* Добавление элемента в очередь */
+        deque.pushLast(4);
+        System.out.println("После добавления элемента 4 в хвост deque = " + Arrays.toString(deque.toArray()));
+        deque.pushFirst(1);
+        System.out.println("После добавления элемента 1 в голову deque = " + Arrays.toString(deque.toArray()));
+
+        /* Извлечение элемента из очереди */
+        int popLast = deque.popLast();
+        System.out.println("Извлеченный из хвоста элемент = " + popLast + ", deque после извлечения из хвоста = " + Arrays.toString(deque.toArray()));
+        int popFirst = deque.popFirst();
+        System.out.println("Извлеченный из головы элемент = " + popFirst + ", deque после извлечения из головы = " + Arrays.toString(deque.toArray()));
+
+        /* Получение длины двусторонней очереди */
+        int size = deque.size();
+        System.out.println("Длина двусторонней очереди size = " + size);
+
+        /* Проверка, пуста ли двусторонняя очередь */
+        boolean isEmpty = deque.isEmpty();
+        System.out.println("Пуста ли двусторонняя очередь = " + isEmpty);
+    }
+}

ru/codes/java/chapter_stack_and_queue/array_queue.java

@@ -0,0 +1,115 @@
+/**
+ * File: array_queue.java
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_stack_and_queue;
+
+import java.util.*;
+
+/* Очередь на основе кольцевого массива */
+class ArrayQueue {
+    private int[] nums; // Массив для хранения элементов очереди
+    private int front; // Указатель head, указывающий на первый элемент очереди
+    private int queSize; // Длина очереди
+
+    public ArrayQueue(int capacity) {
+        nums = new int[capacity];
+        front = queSize = 0;
+    }
+
+    /* Получить вместимость очереди */
+    public int capacity() {
+        return nums.length;
+    }
+
+    /* Получение длины очереди */
+    public int size() {
+        return queSize;
+    }
+
+    /* Проверка, пуста ли очередь */
+    public boolean isEmpty() {
+        return queSize == 0;
+    }
+
+    /* Поместить в очередь */
+    public void push(int num) {
+        if (queSize == capacity()) {
+            System.out.println("Очередь заполнена");
+            return;
+        }
+        // Вычислить указатель хвоста, указывающий на индекс хвоста + 1
+        // С помощью операции взятия по модулю вернуть rear к началу после выхода за конец массива
+        int rear = (front + queSize) % capacity();
+        // Добавить num в хвост очереди
+        nums[rear] = num;
+        queSize++;
+    }
+
+    /* Извлечь из очереди */
+    public int pop() {
+        int num = peek();
+        // Указатель head сдвигается на одну позицию назад; если он выходит за конец, то возвращается в начало массива
+        front = (front + 1) % capacity();
+        queSize--;
+        return num;
+    }
+
+    /* Доступ к элементу в начале очереди */
+    public int peek() {
+        if (isEmpty())
+            throw new IndexOutOfBoundsException();
+        return nums[front];
+    }
+
+    /* Вернуть массив */
+    public int[] toArray() {
+        // Преобразовывать только элементы списка в пределах фактической длины
+        int[] res = new int[queSize];
+        for (int i = 0, j = front; i < queSize; i++, j++) {
+            res[i] = nums[j % capacity()];
+        }
+        return res;
+    }
+}
+
+public class array_queue {
+    public static void main(String[] args) {
+        /* Инициализация очереди */
+        int capacity = 10;
+        ArrayQueue queue = new ArrayQueue(capacity);
+
+        /* Добавление элемента в очередь */
+        queue.push(1);
+        queue.push(3);
+        queue.push(2);
+        queue.push(5);
+        queue.push(4);
+        System.out.println("Очередь queue = " + Arrays.toString(queue.toArray()));
+
+        /* Доступ к элементу в начале очереди */
+        int peek = queue.peek();
+        System.out.println("Первый элемент peek = " + peek);
+
+        /* Извлечение элемента из очереди */
+        int pop = queue.pop();
+        System.out.println("Извлеченный элемент pop = " + pop + ", queue после извлечения = " + Arrays.toString(queue.toArray()));
+
+        /* Получение длины очереди */
+        int size = queue.size();
+        System.out.println("Длина очереди size = " + size);
+
+        /* Проверка, пуста ли очередь */
+        boolean isEmpty = queue.isEmpty();
+        System.out.println("Пуста ли очередь = " + isEmpty);
+
+        /* Проверка кольцевого массива */
+        for (int i = 0; i < 10; i++) {
+            queue.push(i);
+            queue.pop();
+            System.out.println("После " + i + "-го раунда операций enqueue и dequeue queue = " + Arrays.toString(queue.toArray()));
+        }
+    }
+}

ru/codes/java/chapter_stack_and_queue/array_stack.java

@@ -0,0 +1,84 @@
+/**
+ * File: array_stack.java
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_stack_and_queue;
+
+import java.util.*;
+
+/* Стек на основе массива */
+class ArrayStack {
+    private ArrayList<Integer> stack;
+
+    public ArrayStack() {
+        // Инициализация списка (динамического массива)
+        stack = new ArrayList<>();
+    }
+
+    /* Получение длины стека */
+    public int size() {
+        return stack.size();
+    }
+
+    /* Проверка, пуст ли стек */
+    public boolean isEmpty() {
+        return size() == 0;
+    }
+
+    /* Поместить в стек */
+    public void push(int num) {
+        stack.add(num);
+    }
+
+    /* Извлечь из стека */
+    public int pop() {
+        if (isEmpty())
+            throw new IndexOutOfBoundsException();
+        return stack.remove(size() - 1);
+    }
+
+    /* Доступ к верхнему элементу стека */
+    public int peek() {
+        if (isEmpty())
+            throw new IndexOutOfBoundsException();
+        return stack.get(size() - 1);
+    }
+
+    /* Преобразовать List в Array и вернуть */
+    public Object[] toArray() {
+        return stack.toArray();
+    }
+}
+
+public class array_stack {
+    public static void main(String[] args) {
+        /* Инициализация стека */
+        ArrayStack stack = new ArrayStack();
+
+        /* Помещение элемента в стек */
+        stack.push(1);
+        stack.push(3);
+        stack.push(2);
+        stack.push(5);
+        stack.push(4);
+        System.out.println("Стек stack = " + Arrays.toString(stack.toArray()));
+
+        /* Доступ к верхнему элементу стека */
+        int peek = stack.peek();
+        System.out.println("Верхний элемент peek = " + peek);
+
+        /* Извлечение элемента из стека */
+        int pop = stack.pop();
+        System.out.println("Извлеченный элемент pop = " + pop + ", stack после извлечения = " + Arrays.toString(stack.toArray()));
+
+        /* Получение длины стека */
+        int size = stack.size();
+        System.out.println("Длина стека size = " + size);
+
+        /* Проверка на пустоту */
+        boolean isEmpty = stack.isEmpty();
+        System.out.println("Пуст ли стек = " + isEmpty);
+    }
+}

ru/codes/java/chapter_stack_and_queue/deque.java

@@ -0,0 +1,46 @@
+/**
+ * File: deque.java
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_stack_and_queue;
+
+import java.util.*;
+
+public class deque {
+    public static void main(String[] args) {
+        /* Инициализация двусторонней очереди */
+        Deque<Integer> deque = new LinkedList<>();
+        deque.offerLast(3);
+        deque.offerLast(2);
+        deque.offerLast(5);
+        System.out.println("Двусторонняя очередь deque = " + deque);
+
+        /* Доступ к элементу */
+        int peekFirst = deque.peekFirst();
+        System.out.println("Первый элемент peekFirst = " + peekFirst);
+        int peekLast = deque.peekLast();
+        System.out.println("Последний элемент peekLast = " + peekLast);
+
+        /* Добавление элемента в очередь */
+        deque.offerLast(4);
+        System.out.println("После добавления элемента 4 в хвост deque = " + deque);
+        deque.offerFirst(1);
+        System.out.println("После добавления элемента 1 в голову deque = " + deque);
+
+        /* Извлечение элемента из очереди */
+        int popLast = deque.pollLast();
+        System.out.println("Извлеченный из хвоста элемент = " + popLast + ", deque после извлечения из хвоста = " + deque);
+        int popFirst = deque.pollFirst();
+        System.out.println("Извлеченный из головы элемент = " + popFirst + ", deque после извлечения из головы = " + deque);
+
+        /* Получение длины двусторонней очереди */
+        int size = deque.size();
+        System.out.println("Длина двусторонней очереди size = " + size);
+
+        /* Проверка, пуста ли двусторонняя очередь */
+        boolean isEmpty = deque.isEmpty();
+        System.out.println("Пуста ли двусторонняя очередь = " + isEmpty);
+    }
+}

ru/codes/java/chapter_stack_and_queue/linkedlist_deque.java

@@ -0,0 +1,175 @@
+/**
+ * File: linkedlist_deque.java
+ * Created Time: 2023-01-20
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_stack_and_queue;
+
+import java.util.*;
+
+/* Узел двусвязного списка */
+class ListNode {
+    int val; // Значение узла
+    ListNode next; // Ссылка на узел-преемник
+    ListNode prev; // Ссылка на узел-предшественник
+
+    ListNode(int val) {
+        this.val = val;
+        prev = next = null;
+    }
+}
+
+/* Двусторонняя очередь на основе двусвязного списка */
+class LinkedListDeque {
+    private ListNode front, rear; // Головной узел front, хвостовой узел rear
+    private int queSize = 0; // Длина двусторонней очереди
+
+    public LinkedListDeque() {
+        front = rear = null;
+    }
+
+    /* Получение длины двусторонней очереди */
+    public int size() {
+        return queSize;
+    }
+
+    /* Проверка, пуста ли двусторонняя очередь */
+    public boolean isEmpty() {
+        return size() == 0;
+    }
+
+    /* Операция добавления в очередь */
+    private void push(int num, boolean isFront) {
+        ListNode node = new ListNode(num);
+        // Если связный список пуст, сделать так, чтобы и front, и rear указывали на node
+        if (isEmpty())
+            front = rear = node;
+        // Операция добавления в голову очереди
+        else if (isFront) {
+            // Добавить node в голову списка
+            front.prev = node;
+            node.next = front;
+            front = node; // Обновить головной узел
+        // Операция добавления в хвост очереди
+        } else {
+            // Добавить node в хвост списка
+            rear.next = node;
+            node.prev = rear;
+            rear = node; // Обновить хвостовой узел
+        }
+        queSize++; // Обновить длину очереди
+    }
+
+    /* Добавление в голову очереди */
+    public void pushFirst(int num) {
+        push(num, true);
+    }
+
+    /* Добавление в хвост очереди */
+    public void pushLast(int num) {
+        push(num, false);
+    }
+
+    /* Операция извлечения из очереди */
+    private int pop(boolean isFront) {
+        if (isEmpty())
+            throw new IndexOutOfBoundsException();
+        int val;
+        // Операция извлечения из головы очереди
+        if (isFront) {
+            val = front.val; // Временно сохранить значение головного узла
+            // Удалить головной узел
+            ListNode fNext = front.next;
+            if (fNext != null) {
+                fNext.prev = null;
+                front.next = null;
+            }
+            front = fNext; // Обновить головной узел
+        // Операция извлечения из хвоста очереди
+        } else {
+            val = rear.val; // Временно сохранить значение хвостового узла
+            // Удалить хвостовой узел
+            ListNode rPrev = rear.prev;
+            if (rPrev != null) {
+                rPrev.next = null;
+                rear.prev = null;
+            }
+            rear = rPrev; // Обновить хвостовой узел
+        }
+        queSize--; // Обновить длину очереди
+        return val;
+    }
+
+    /* Извлечение из головы очереди */
+    public int popFirst() {
+        return pop(true);
+    }
+
+    /* Извлечение из хвоста очереди */
+    public int popLast() {
+        return pop(false);
+    }
+
+    /* Доступ к элементу в начале очереди */
+    public int peekFirst() {
+        if (isEmpty())
+            throw new IndexOutOfBoundsException();
+        return front.val;
+    }
+
+    /* Доступ к элементу в конце очереди */
+    public int peekLast() {
+        if (isEmpty())
+            throw new IndexOutOfBoundsException();
+        return rear.val;
+    }
+
+    /* Вернуть массив для вывода */
+    public int[] toArray() {
+        ListNode node = front;
+        int[] res = new int[size()];
+        for (int i = 0; i < res.length; i++) {
+            res[i] = node.val;
+            node = node.next;
+        }
+        return res;
+    }
+}
+
+public class linkedlist_deque {
+    public static void main(String[] args) {
+        /* Инициализация двусторонней очереди */
+        LinkedListDeque deque = new LinkedListDeque();
+        deque.pushLast(3);
+        deque.pushLast(2);
+        deque.pushLast(5);
+        System.out.println("Двусторонняя очередь deque = " + Arrays.toString(deque.toArray()));
+
+        /* Доступ к элементу */
+        int peekFirst = deque.peekFirst();
+        System.out.println("Первый элемент peekFirst = " + peekFirst);
+        int peekLast = deque.peekLast();
+        System.out.println("Последний элемент peekLast = " + peekLast);
+
+        /* Добавление элемента в очередь */
+        deque.pushLast(4);
+        System.out.println("После добавления элемента 4 в хвост deque = " + Arrays.toString(deque.toArray()));
+        deque.pushFirst(1);
+        System.out.println("После добавления элемента 1 в голову deque = " + Arrays.toString(deque.toArray()));
+
+        /* Извлечение элемента из очереди */
+        int popLast = deque.popLast();
+        System.out.println("Извлеченный из хвоста элемент = " + popLast + ", deque после извлечения из хвоста = " + Arrays.toString(deque.toArray()));
+        int popFirst = deque.popFirst();
+        System.out.println("Извлеченный из головы элемент = " + popFirst + ", deque после извлечения из головы = " + Arrays.toString(deque.toArray()));
+
+        /* Получение длины двусторонней очереди */
+        int size = deque.size();
+        System.out.println("Длина двусторонней очереди size = " + size);
+
+        /* Проверка, пуста ли двусторонняя очередь */
+        boolean isEmpty = deque.isEmpty();
+        System.out.println("Пуста ли двусторонняя очередь = " + isEmpty);
+    }
+}

ru/codes/java/chapter_stack_and_queue/linkedlist_queue.java

@@ -0,0 +1,104 @@
+/**
+ * File: linkedlist_queue.java
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_stack_and_queue;
+
+import java.util.*;
+
+/* Очередь на основе связного списка */
+class LinkedListQueue {
+    private ListNode front, rear; // Головной узел front, хвостовой узел rear
+    private int queSize = 0;
+
+    public LinkedListQueue() {
+        front = null;
+        rear = null;
+    }
+
+    /* Получение длины очереди */
+    public int size() {
+        return queSize;
+    }
+
+    /* Проверка, пуста ли очередь */
+    public boolean isEmpty() {
+        return size() == 0;
+    }
+
+    /* Поместить в очередь */
+    public void push(int num) {
+        // Добавить num после хвостового узла
+        ListNode node = new ListNode(num);
+        // Если очередь пуста, сделать так, чтобы и head, и tail указывали на этот узел
+        if (front == null) {
+            front = node;
+            rear = node;
+        // Если очередь не пуста, добавить этот узел после хвостового узла
+        } else {
+            rear.next = node;
+            rear = node;
+        }
+        queSize++;
+    }
+
+    /* Извлечь из очереди */
+    public int pop() {
+        int num = peek();
+        // Удалить головной узел
+        front = front.next;
+        queSize--;
+        return num;
+    }
+
+    /* Доступ к элементу в начале очереди */
+    public int peek() {
+        if (isEmpty())
+            throw new IndexOutOfBoundsException();
+        return front.val;
+    }
+
+    /* Преобразовать связный список в Array и вернуть */
+    public int[] toArray() {
+        ListNode node = front;
+        int[] res = new int[size()];
+        for (int i = 0; i < res.length; i++) {
+            res[i] = node.val;
+            node = node.next;
+        }
+        return res;
+    }
+}
+
+public class linkedlist_queue {
+    public static void main(String[] args) {
+        /* Инициализация очереди */
+        LinkedListQueue queue = new LinkedListQueue();
+
+        /* Добавление элемента в очередь */
+        queue.push(1);
+        queue.push(3);
+        queue.push(2);
+        queue.push(5);
+        queue.push(4);
+        System.out.println("Очередь queue = " + Arrays.toString(queue.toArray()));
+
+        /* Доступ к элементу в начале очереди */
+        int peek = queue.peek();
+        System.out.println("Первый элемент peek = " + peek);
+
+        /* Извлечение элемента из очереди */
+        int pop = queue.pop();
+        System.out.println("Извлеченный элемент pop = " + pop + ", queue после извлечения = " + Arrays.toString(queue.toArray()));
+
+        /* Получение длины очереди */
+        int size = queue.size();
+        System.out.println("Длина очереди size = " + size);
+
+        /* Проверка, пуста ли очередь */
+        boolean isEmpty = queue.isEmpty();
+        System.out.println("Пуста ли очередь = " + isEmpty);
+    }
+}

ru/codes/java/chapter_stack_and_queue/linkedlist_stack.java

@@ -0,0 +1,95 @@
+/**
+ * File: linkedlist_stack.java
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_stack_and_queue;
+
+import java.util.*;
+import utils.*;
+
+/* Стек на основе связного списка */
+class LinkedListStack {
+    private ListNode stackPeek; // Использовать головной узел как вершину стека
+    private int stkSize = 0; // Длина стека
+
+    public LinkedListStack() {
+        stackPeek = null;
+    }
+
+    /* Получение длины стека */
+    public int size() {
+        return stkSize;
+    }
+
+    /* Проверка, пуст ли стек */
+    public boolean isEmpty() {
+        return size() == 0;
+    }
+
+    /* Поместить в стек */
+    public void push(int num) {
+        ListNode node = new ListNode(num);
+        node.next = stackPeek;
+        stackPeek = node;
+        stkSize++;
+    }
+
+    /* Извлечь из стека */
+    public int pop() {
+        int num = peek();
+        stackPeek = stackPeek.next;
+        stkSize--;
+        return num;
+    }
+
+    /* Доступ к верхнему элементу стека */
+    public int peek() {
+        if (isEmpty())
+            throw new IndexOutOfBoundsException();
+        return stackPeek.val;
+    }
+
+    /* Преобразовать List в Array и вернуть */
+    public int[] toArray() {
+        ListNode node = stackPeek;
+        int[] res = new int[size()];
+        for (int i = res.length - 1; i >= 0; i--) {
+            res[i] = node.val;
+            node = node.next;
+        }
+        return res;
+    }
+}
+
+public class linkedlist_stack {
+    public static void main(String[] args) {
+        /* Инициализация стека */
+        LinkedListStack stack = new LinkedListStack();
+
+        /* Помещение элемента в стек */
+        stack.push(1);
+        stack.push(3);
+        stack.push(2);
+        stack.push(5);
+        stack.push(4);
+        System.out.println("Стек stack = " + Arrays.toString(stack.toArray()));
+
+        /* Доступ к верхнему элементу стека */
+        int peek = stack.peek();
+        System.out.println("Верхний элемент peek = " + peek);
+
+        /* Извлечение элемента из стека */
+        int pop = stack.pop();
+        System.out.println("Извлеченный элемент pop = " + pop + ", stack после извлечения = " + Arrays.toString(stack.toArray()));
+
+        /* Получение длины стека */
+        int size = stack.size();
+        System.out.println("Длина стека size = " + size);
+
+        /* Проверка на пустоту */
+        boolean isEmpty = stack.isEmpty();
+        System.out.println("Пуст ли стек = " + isEmpty);
+    }
+}

ru/codes/java/chapter_stack_and_queue/queue.java

@@ -0,0 +1,40 @@
+/**
+ * File: queue.java
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_stack_and_queue;
+
+import java.util.*;
+
+public class queue {
+    public static void main(String[] args) {
+        /* Инициализация очереди */
+        Queue<Integer> queue = new LinkedList<>();
+
+        /* Добавление элемента в очередь */
+        queue.offer(1);
+        queue.offer(3);
+        queue.offer(2);
+        queue.offer(5);
+        queue.offer(4);
+        System.out.println("Очередь queue = " + queue);
+
+        /* Доступ к элементу в начале очереди */
+        int peek = queue.peek();
+        System.out.println("Первый элемент peek = " + peek);
+
+        /* Извлечение элемента из очереди */
+        int pop = queue.poll();
+        System.out.println("Извлеченный элемент pop = " + pop + ", queue после извлечения = " + queue);
+
+        /* Получение длины очереди */
+        int size = queue.size();
+        System.out.println("Длина очереди size = " + size);
+
+        /* Проверка, пуста ли очередь */
+        boolean isEmpty = queue.isEmpty();
+        System.out.println("Пуста ли очередь = " + isEmpty);
+    }
+}

ru/codes/java/chapter_stack_and_queue/stack.java

@@ -0,0 +1,40 @@
+/**
+ * File: stack.java
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+package chapter_stack_and_queue;
+
+import java.util.*;
+
+public class stack {
+    public static void main(String[] args) {
+        /* Инициализация стека */
+        Stack<Integer> stack = new Stack<>();
+
+        /* Помещение элемента в стек */
+        stack.push(1);
+        stack.push(3);
+        stack.push(2);
+        stack.push(5);
+        stack.push(4);
+        System.out.println("Стек stack = " + stack);
+
+        /* Доступ к верхнему элементу стека */
+        int peek = stack.peek();
+        System.out.println("Верхний элемент peek = " + peek);
+
+        /* Извлечение элемента из стека */
+        int pop = stack.pop();
+        System.out.println("Извлеченный элемент pop = " + pop + ", stack после извлечения = " + stack);
+
+        /* Получение длины стека */
+        int size = stack.size();
+        System.out.println("Длина стека size = " + size);
+
+        /* Проверка на пустоту */
+        boolean isEmpty = stack.isEmpty();
+        System.out.println("Пуст ли стек = " + isEmpty);
+    }
+}

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

ru/codes/java/utils/ListNode.java

@@ -0,0 +1,28 @@
+/**
+ * File: ListNode.java
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+package utils;
+
+/* Узел связного списка */
+public class ListNode {
+    public int val;
+    public ListNode next;
+
+    public ListNode(int x) {
+        val = x;
+    }
+
+    /* Десериализовать список в связный список */
+    public static ListNode arrToLinkedList(int[] arr) {
+        ListNode dum = new ListNode(0);
+        ListNode head = dum;
+        for (int val : arr) {
+            head.next = new ListNode(val);
+            head = head.next;
+        }
+        return dum.next;
+    }
+}

ru/codes/java/utils/PrintUtil.java

@@ -0,0 +1,116 @@
+/**
+ * File: PrintUtil.java
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+package utils;
+
+import java.util.*;
+
+class Trunk {
+    Trunk prev;
+    String str;
+
+    Trunk(Trunk prev, String str) {
+        this.prev = prev;
+        this.str = str;
+    }
+};
+
+public class PrintUtil {
+    /* Вывести матрицу (Array) */
+    public static <T> void printMatrix(T[][] matrix) {
+        System.out.println("[");
+        for (T[] row : matrix) {
+            System.out.println("  " + row + ",");
+        }
+        System.out.println("]");
+    }
+
+    /* Вывести матрицу (List) */
+    public static <T> void printMatrix(List<List<T>> matrix) {
+        System.out.println("[");
+        for (List<T> row : matrix) {
+            System.out.println("  " + row + ",");
+        }
+        System.out.println("]");
+    }
+
+    /* Вывести связный список */
+    public static void printLinkedList(ListNode head) {
+        List<String> list = new ArrayList<>();
+        while (head != null) {
+            list.add(String.valueOf(head.val));
+            head = head.next;
+        }
+        System.out.println(String.join(" -> ", list));
+    }
+
+    /* Вывести двоичное дерево */
+    public static void printTree(TreeNode root) {
+        printTree(root, null, false);
+    }
+
+    /**
+ * Вывести двоичное дерево
+ * Этот вывод дерева заимствован из TECHIE DELIGHT
+ * https://www.techiedelight.com/c-program-print-binary-tree/
+ */
+    public static void printTree(TreeNode root, Trunk prev, boolean isRight) {
+        if (root == null) {
+            return;
+        }
+
+        String prev_str = "    ";
+        Trunk trunk = new Trunk(prev, prev_str);
+
+        printTree(root.right, trunk, true);
+
+        if (prev == null) {
+            trunk.str = "———";
+        } else if (isRight) {
+            trunk.str = "/———";
+            prev_str = "   |";
+        } else {
+            trunk.str = "\\———";
+            prev.str = prev_str;
+        }
+
+        showTrunks(trunk);
+        System.out.println(" " + root.val);
+
+        if (prev != null) {
+            prev.str = prev_str;
+        }
+        trunk.str = "   |";
+
+        printTree(root.left, trunk, false);
+    }
+
+    public static void showTrunks(Trunk p) {
+        if (p == null) {
+            return;
+        }
+
+        showTrunks(p.prev);
+        System.out.print(p.str);
+    }
+
+    /* Вывести хеш-таблицу */
+    public static <K, V> void printHashMap(Map<K, V> map) {
+        for (Map.Entry<K, V> kv : map.entrySet()) {
+            System.out.println(kv.getKey() + " -> " + kv.getValue());
+        }
+    }
+
+    /* Вывести кучу (приоритетную очередь) */
+    public static void printHeap(Queue<Integer> queue) {
+        List<Integer> list = new ArrayList<>(queue);
+        System.out.print("Массивное представление кучи:");
+        System.out.println(list);
+        System.out.println("Древовидное представление кучи:");
+        TreeNode root = TreeNode.listToTree(list);
+        printTree(root);
+    }
+}

ru/codes/java/utils/TreeNode.java

@@ -0,0 +1,73 @@
+/**
+ * File: TreeNode.java
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+package utils;
+
+import java.util.*;
+
+/* Класс узла двоичного дерева */
+public class TreeNode {
+    public int val; // Значение узла
+    public int height; // Высота узла
+    public TreeNode left; // Ссылка на левый дочерний узел
+    public TreeNode right; // Ссылка на правый дочерний узел
+
+    /* Конструктор */
+    public TreeNode(int x) {
+        val = x;
+    }
+
+    // Правила кодирования сериализации см.:
+    // 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
+
+    /* Десериализовать список в двоичное дерево: рекурсия */
+    private static TreeNode listToTreeDFS(List<Integer> arr, int i) {
+        if (i < 0 || i >= arr.size() || arr.get(i) == null) {
+            return null;
+        }
+        TreeNode root = new TreeNode(arr.get(i));
+        root.left = listToTreeDFS(arr, 2 * i + 1);
+        root.right = listToTreeDFS(arr, 2 * i + 2);
+        return root;
+    }
+
+    /* Десериализовать список в двоичное дерево */
+    public static TreeNode listToTree(List<Integer> arr) {
+        return listToTreeDFS(arr, 0);
+    }
+
+    /* Сериализовать двоичное дерево в список: рекурсия */
+    private static void treeToListDFS(TreeNode root, int i, List<Integer> res) {
+        if (root == null)
+            return;
+        while (i >= res.size()) {
+            res.add(null);
+        }
+        res.set(i, root.val);
+        treeToListDFS(root.left, 2 * i + 1, res);
+        treeToListDFS(root.right, 2 * i + 2, res);
+    }
+
+    /* Сериализовать двоичное дерево в список */
+    public static List<Integer> treeToList(TreeNode root) {
+        List<Integer> res = new ArrayList<>();
+        treeToListDFS(root, 0, res);
+        return res;
+    }
+}

ru/codes/java/utils/Vertex.java

@@ -0,0 +1,36 @@
+/**
+ * File: Vertex.java
+ * Created Time: 2023-02-15
+ * Author: krahets (krahets@163.com)
+ */
+
+package utils;
+
+import java.util.*;
+
+/* Класс вершины */
+public class Vertex {
+    public int val;
+
+    public Vertex(int val) {
+        this.val = val;
+    }
+
+    /* На вход подается список значений vals, на выходе возвращается список вершин vets */
+    public static Vertex[] valsToVets(int[] vals) {
+        Vertex[] vets = new Vertex[vals.length];
+        for (int i = 0; i < vals.length; i++) {
+            vets[i] = new Vertex(vals[i]);
+        }
+        return vets;
+    }
+
+    /* На вход подается список вершин vets, на выходе возвращается список значений vals */
+    public static List<Integer> vetsToVals(List<Vertex> vets) {
+        List<Integer> vals = new ArrayList<>();
+        for (Vertex vet : vets) {
+            vals.add(vet.val);
+        }
+        return vals;
+    }
+}