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

@@ -0,0 +1,10 @@
+# Ignore all
+*
+# Unignore all with extensions
+!*.*
+# Unignore all dirs
+!*/
+
+*.dSYM/
+
+build/

ru/codes/cpp/CMakeLists.txt

@@ -0,0 +1,20 @@
+cmake_minimum_required(VERSION 3.10)
+project(hello_algo CXX)
+
+set(CMAKE_CXX_STANDARD 11)
+
+include_directories(./include)
+
+add_subdirectory(chapter_computational_complexity)
+add_subdirectory(chapter_array_and_linkedlist)
+add_subdirectory(chapter_stack_and_queue)
+add_subdirectory(chapter_hashing)
+add_subdirectory(chapter_tree)
+add_subdirectory(chapter_heap)
+add_subdirectory(chapter_graph)
+add_subdirectory(chapter_searching)
+add_subdirectory(chapter_sorting)
+add_subdirectory(chapter_divide_and_conquer)
+add_subdirectory(chapter_backtracking)
+add_subdirectory(chapter_dynamic_programming)
+add_subdirectory(chapter_greedy)

ru/codes/cpp/chapter_array_and_linkedlist/CMakeLists.txt

@@ -0,0 +1,4 @@
+add_executable(array array.cpp)
+add_executable(linked_list linked_list.cpp)
+add_executable(list list.cpp)
+add_executable(my_list my_list.cpp)

ru/codes/cpp/chapter_array_and_linkedlist/array.cpp

@@ -0,0 +1,113 @@
+/**
+ * File: array.cpp
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Случайный доступ к элементу */
+int randomAccess(int *nums, int size) {
+    // Случайным образом выбрать число из интервала [0, size)
+    int randomIndex = rand() % size;
+    // Получить и вернуть случайный элемент
+    int randomNum = nums[randomIndex];
+    return randomNum;
+}
+
+/* Увеличить длину массива */
+int *extend(int *nums, int size, int enlarge) {
+    // Инициализировать массив увеличенной длины
+    int *res = new int[size + enlarge];
+    // Скопировать все элементы исходного массива в новый массив
+    for (int i = 0; i < size; i++) {
+        res[i] = nums[i];
+    }
+    // Освободить память
+    delete[] nums;
+    // Вернуть новый массив после расширения
+    return res;
+}
+
+/* Вставить элемент num по индексу index в массив */
+void insert(int *nums, int size, int num, int index) {
+    // Сдвинуть элемент с индексом index и все последующие элементы на одну позицию назад
+    for (int i = size - 1; i > index; i--) {
+        nums[i] = nums[i - 1];
+    }
+    // Присвоить num элементу по индексу index
+    nums[index] = num;
+}
+
+/* Удалить элемент по индексу index */
+void remove(int *nums, int size, int index) {
+    // Сдвинуть все элементы после индекса index на одну позицию вперед
+    for (int i = index; i < size - 1; i++) {
+        nums[i] = nums[i + 1];
+    }
+}
+
+/* Обход массива */
+void traverse(int *nums, int size) {
+    int count = 0;
+    // Обход массива по индексам
+    for (int i = 0; i < size; i++) {
+        count += nums[i];
+    }
+}
+
+/* Найти заданный элемент в массиве */
+int find(int *nums, int size, int target) {
+    for (int i = 0; i < size; i++) {
+        if (nums[i] == target)
+            return i;
+    }
+    return -1;
+}
+
+/* Driver Code */
+int main() {
+    /* Инициализация массива */
+    int size = 5;
+    int *arr = new int[size];
+    cout << "Массив arr = ";
+    printArray(arr, size);
+
+    int *nums = new int[size]{1, 3, 2, 5, 4};
+    cout << "Массив nums = ";
+    printArray(nums, size);
+
+    /* Случайный доступ */
+    int randomNum = randomAccess(nums, size);
+    cout << "Случайный элемент из nums = " << randomNum << endl;
+
+    /* Расширение длины */
+    int enlarge = 3;
+    nums = extend(nums, size, enlarge);
+    size += enlarge;
+    cout << "После увеличения длины массива до 8 nums = ";
+    printArray(nums, size);
+
+    /* Вставка элемента */
+    insert(nums, size, 6, 3);
+    cout << "После вставки числа 6 по индексу 3 nums = ";
+    printArray(nums, size);
+
+    /* Удаление элемента */
+    remove(nums, size, 2);
+    cout << "После удаления элемента по индексу 2 nums = ";
+    printArray(nums, size);
+
+    /* Обход массива */
+    traverse(nums, size);
+
+    /* Поиск элемента */
+    int index = find(nums, size, 3);
+    cout << "Индекс элемента 3 в nums = " << index << endl;
+
+    // Освободить память
+    delete[] arr;
+    delete[] nums;
+
+    return 0;
+}

ru/codes/cpp/chapter_array_and_linkedlist/linked_list.cpp

@@ -0,0 +1,89 @@
+/**
+ * File: linked_list.cpp
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Вставить узел P после узла n0 в связном списке */
+void insert(ListNode *n0, ListNode *P) {
+    ListNode *n1 = n0->next;
+    P->next = n1;
+    n0->next = P;
+}
+
+/* Удалить первый узел после узла n0 в связном списке */
+void remove(ListNode *n0) {
+    if (n0->next == nullptr)
+        return;
+    // n0 -> P -> n1
+    ListNode *P = n0->next;
+    ListNode *n1 = P->next;
+    n0->next = n1;
+    // Освободить память
+    delete P;
+}
+
+/* Доступ к узлу связного списка по индексу index */
+ListNode *access(ListNode *head, int index) {
+    for (int i = 0; i < index; i++) {
+        if (head == nullptr)
+            return nullptr;
+        head = head->next;
+    }
+    return head;
+}
+
+/* Найти в связном списке первый узел со значением target */
+int find(ListNode *head, int target) {
+    int index = 0;
+    while (head != nullptr) {
+        if (head->val == target)
+            return index;
+        head = head->next;
+        index++;
+    }
+    return -1;
+}
+
+/* Driver Code */
+int main() {
+    /* Инициализация связного списка */
+    // Инициализация всех узлов
+    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;
+    cout << "Инициализированный связный список" << endl;
+    printLinkedList(n0);
+
+    /* Вставка узла */
+    insert(n0, new ListNode(0));
+    cout << "Связный список после вставки узла" << endl;
+    printLinkedList(n0);
+
+    /* Удаление узла */
+    remove(n0);
+    cout << "Связный список после удаления узла" << endl;
+    printLinkedList(n0);
+
+    /* Доступ к узлу */
+    ListNode *node = access(n0, 3);
+    cout << "Значение узла по индексу 3 в связном списке = " << node->val << endl;
+
+    /* Поиск узла */
+    int index = find(n0, 2);
+    cout << "Индекс узла со значением 2 в связном списке = " << index << endl;
+
+    // Освободить память
+    freeMemoryLinkedList(n0);
+
+    return 0;
+}

ru/codes/cpp/chapter_array_and_linkedlist/list.cpp

@@ -0,0 +1,72 @@
+/**
+ * File: list.cpp
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Driver Code */
+int main() {
+    /* Инициализация списка */
+    vector<int> nums = {1, 3, 2, 5, 4};
+    cout << "Список nums = ";
+    printVector(nums);
+
+    /* Доступ к элементу */
+    int num = nums[1];
+    cout << "Элемент по индексу 1: num = " << num << endl;
+
+    /* Обновление элемента */
+    nums[1] = 0;
+    cout << "После обновления элемента по индексу 1 на 0 nums = ";
+    printVector(nums);
+
+    /* Очистить список */
+    nums.clear();
+    cout << "После очистки списка nums = ";
+    printVector(nums);
+
+    /* Добавление элемента в конец */
+    nums.push_back(1);
+    nums.push_back(3);
+    nums.push_back(2);
+    nums.push_back(5);
+    nums.push_back(4);
+    cout << "После добавления элемента nums = ";
+    printVector(nums);
+
+    /* Вставка элемента в середину */
+    nums.insert(nums.begin() + 3, 6);
+    cout << "После вставки числа 6 по индексу 3 nums = ";
+    printVector(nums);
+
+    /* Удаление элемента */
+    nums.erase(nums.begin() + 3);
+    cout << "После удаления элемента по индексу 3 nums = ";
+    printVector(nums);
+
+    /* Обходить список по индексам */
+    int count = 0;
+    for (int i = 0; i < nums.size(); i++) {
+        count += nums[i];
+    }
+    /* Непосредственно обходить элементы списка */
+    count = 0;
+    for (int x : nums) {
+        count += x;
+    }
+
+    /* Объединить два списка */
+    vector<int> nums1 = {6, 8, 7, 10, 9};
+    nums.insert(nums.end(), nums1.begin(), nums1.end());
+    cout << "После присоединения списка nums1 к nums nums = ";
+    printVector(nums);
+
+    /* Отсортировать список */
+    sort(nums.begin(), nums.end());
+    cout << "После сортировки списка nums = ";
+    printVector(nums);
+
+    return 0;
+}

ru/codes/cpp/chapter_array_and_linkedlist/my_list.cpp

@@ -0,0 +1,171 @@
+/**
+ * File: my_list.cpp
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Класс списка */
+class MyList {
+  private:
+    int *arr;             // Массив (для хранения элементов списка)
+    int arrCapacity = 10; // Вместимость списка
+    int arrSize = 0;      // Длина списка (текущее число элементов)
+    int extendRatio = 2;   // Коэффициент увеличения списка при каждом расширении
+
+  public:
+    /* Конструктор */
+    MyList() {
+        arr = new int[arrCapacity];
+    }
+
+    /* Метод-деструктор */
+    ~MyList() {
+        delete[] arr;
+    }
+
+    /* Получить длину списка (текущее число элементов) */
+    int size() {
+        return arrSize;
+    }
+
+    /* Получить вместимость списка */
+    int capacity() {
+        return arrCapacity;
+    }
+
+    /* Доступ к элементу */
+    int get(int index) {
+        // Если индекс выходит за границы, выбрасывается исключение; далее аналогично
+        if (index < 0 || index >= size())
+            throw out_of_range("индекс выходит за границы");
+        return arr[index];
+    }
+
+    /* Обновление элемента */
+    void set(int index, int num) {
+        if (index < 0 || index >= size())
+            throw out_of_range("индекс выходит за границы");
+        arr[index] = num;
+    }
+
+    /* Добавление элемента в конец */
+    void add(int num) {
+        // При превышении вместимости по числу элементов запускается расширение
+        if (size() == capacity())
+            extendCapacity();
+        arr[size()] = num;
+        // Обновить число элементов
+        arrSize++;
+    }
+
+    /* Вставка элемента в середину */
+    void insert(int index, int num) {
+        if (index < 0 || index >= size())
+            throw out_of_range("индекс выходит за границы");
+        // При превышении вместимости по числу элементов запускается расширение
+        if (size() == capacity())
+            extendCapacity();
+        // Сдвинуть элемент с индексом index и все следующие элементы на одну позицию назад
+        for (int j = size() - 1; j >= index; j--) {
+            arr[j + 1] = arr[j];
+        }
+        arr[index] = num;
+        // Обновить число элементов
+        arrSize++;
+    }
+
+    /* Удаление элемента */
+    int remove(int index) {
+        if (index < 0 || index >= size())
+            throw out_of_range("индекс выходит за границы");
+        int num = arr[index];
+        // Сдвинуть все элементы после индекса index на одну позицию вперед
+        for (int j = index; j < size() - 1; j++) {
+            arr[j] = arr[j + 1];
+        }
+        // Обновить число элементов
+        arrSize--;
+        // Вернуть удаленный элемент
+        return num;
+    }
+
+    /* Расширение списка */
+    void extendCapacity() {
+        // Создать новый массив длиной в extendRatio раз больше исходного массива
+        int newCapacity = capacity() * extendRatio;
+        int *tmp = arr;
+        arr = new int[newCapacity];
+        // Скопировать все элементы исходного массива в новый массив
+        for (int i = 0; i < size(); i++) {
+            arr[i] = tmp[i];
+        }
+        // Освободить память
+        delete[] tmp;
+        arrCapacity = newCapacity;
+    }
+
+    /* Преобразовать список в Vector для вывода */
+    vector<int> toVector() {
+        // Преобразовывать только элементы списка в пределах фактической длины
+        vector<int> vec(size());
+        for (int i = 0; i < size(); i++) {
+            vec[i] = arr[i];
+        }
+        return vec;
+    }
+};
+
+/* Driver Code */
+int main() {
+    /* Инициализация списка */
+    MyList *nums = new MyList();
+    /* Добавление элемента в конец */
+    nums->add(1);
+    nums->add(3);
+    nums->add(2);
+    nums->add(5);
+    nums->add(4);
+    cout << "Список nums = ";
+    vector<int> vec = nums->toVector();
+    printVector(vec);
+    cout << "Вместимость = " << nums->capacity() << ", длина = " << nums->size() << endl;
+
+    /* Вставка элемента в середину */
+    nums->insert(3, 6);
+    cout << "После вставки числа 6 по индексу 3 nums = ";
+    vec = nums->toVector();
+    printVector(vec);
+
+    /* Удаление элемента */
+    nums->remove(3);
+    cout << "После удаления элемента по индексу 3 nums = ";
+    vec = nums->toVector();
+    printVector(vec);
+
+    /* Доступ к элементу */
+    int num = nums->get(1);
+    cout << "Элемент по индексу 1: num = " << num << endl;
+
+    /* Обновление элемента */
+    nums->set(1, 0);
+    cout << "После обновления элемента по индексу 1 на 0 nums = ";
+    vec = nums->toVector();
+    printVector(vec);
+
+    /* Проверка механизма расширения */
+    for (int i = 0; i < 10; i++) {
+        // При i = 5 длина списка превысит его вместимость, и в этот момент сработает механизм расширения
+        nums->add(i);
+    }
+    cout << "После расширения список nums = ";
+    vec = nums->toVector();
+    printVector(vec);
+    cout << "Вместимость = " << nums->capacity() << ", длина = " << nums->size() << endl;
+
+    // Освободить память
+    delete nums;
+
+    return 0;
+}

ru/codes/cpp/chapter_backtracking/CMakeLists.txt

@@ -0,0 +1,10 @@
+add_executable(preorder_traversal_i_compact preorder_traversal_i_compact.cpp)
+add_executable(preorder_traversal_ii_compact preorder_traversal_ii_compact.cpp)
+add_executable(preorder_traversal_iii_compact preorder_traversal_iii_compact.cpp)
+add_executable(preorder_traversal_iii_template preorder_traversal_iii_template.cpp)
+add_executable(permutations_i permutations_i.cpp)
+add_executable(permutations_ii permutations_ii.cpp)
+add_executable(n_queens n_queens.cpp)
+add_executable(subset_sum_i_naive subset_sum_i_naive.cpp)
+add_executable(subset_sum_i subset_sum_i.cpp)
+add_executable(subset_sum_ii subset_sum_ii.cpp)

ru/codes/cpp/chapter_backtracking/n_queens.cpp

@@ -0,0 +1,65 @@
+/**
+ * File: n_queens.cpp
+ * Created Time: 2023-05-04
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Алгоритм бэктрекинга: n ферзей */
+void backtrack(int row, int n, vector<vector<string>> &state, vector<vector<vector<string>>> &res, vector<bool> &cols,
+               vector<bool> &diags1, vector<bool> &diags2) {
+    // Когда все строки уже обработаны, записать решение
+    if (row == n) {
+        res.push_back(state);
+        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[row][col] = "Q";
+            cols[col] = diags1[diag1] = diags2[diag2] = true;
+            // Перейти к размещению следующей строки
+            backtrack(row + 1, n, state, res, cols, diags1, diags2);
+            // Откат: восстановить эту клетку как пустую
+            state[row][col] = "#";
+            cols[col] = diags1[diag1] = diags2[diag2] = false;
+        }
+    }
+}
+
+/* Решить задачу о n ферзях */
+vector<vector<vector<string>>> nQueens(int n) {
+    // Инициализировать доску размера n*n, где 'Q' обозначает ферзя, а '#' — пустую клетку
+    vector<vector<string>> state(n, vector<string>(n, "#"));
+    vector<bool> cols(n, false);           // Отмечать, есть ли ферзь в столбце
+    vector<bool> diags1(2 * n - 1, false); // Отмечать наличие ферзя на главной диагонали
+    vector<bool> diags2(2 * n - 1, false); // Отмечать наличие ферзя на побочной диагонали
+    vector<vector<vector<string>>> res;
+
+    backtrack(0, n, state, res, cols, diags1, diags2);
+
+    return res;
+}
+
+/* Driver Code */
+int main() {
+    int n = 4;
+    vector<vector<vector<string>>> res = nQueens(n);
+
+    cout << "Размер входной доски = " << n << endl;
+    cout << "Количество способов расстановки ферзей: " << res.size() << endl;
+    for (const vector<vector<string>> &state : res) {
+        cout << "--------------------" << endl;
+        for (const vector<string> &row : state) {
+            printVector(row);
+        }
+    }
+
+    return 0;
+}

ru/codes/cpp/chapter_backtracking/permutations_i.cpp

@@ -0,0 +1,54 @@
+/**
+ * File: permutations_i.cpp
+ * Created Time: 2023-04-24
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Алгоритм бэктрекинга: все перестановки I */
+void backtrack(vector<int> &state, const vector<int> &choices, vector<bool> &selected, vector<vector<int>> &res) {
+    // Когда длина состояния равна числу элементов, записать решение
+    if (state.size() == choices.size()) {
+        res.push_back(state);
+        return;
+    }
+    // Перебор всех вариантов выбора
+    for (int i = 0; i < choices.size(); i++) {
+        int choice = choices[i];
+        // Отсечение: нельзя выбирать один и тот же элемент повторно
+        if (!selected[i]) {
+            // Попытка: сделать выбор и обновить состояние
+            selected[i] = true;
+            state.push_back(choice);
+            // Перейти к следующему выбору
+            backtrack(state, choices, selected, res);
+            // Откат: отменить выбор и восстановить предыдущее состояние
+            selected[i] = false;
+            state.pop_back();
+        }
+    }
+}
+
+/* Все перестановки I */
+vector<vector<int>> permutationsI(vector<int> nums) {
+    vector<int> state;
+    vector<bool> selected(nums.size(), false);
+    vector<vector<int>> res;
+    backtrack(state, nums, selected, res);
+    return res;
+}
+
+/* Driver Code */
+int main() {
+    vector<int> nums = {1, 2, 3};
+
+    vector<vector<int>> res = permutationsI(nums);
+
+    cout << "Входной массив nums = ";
+    printVector(nums);
+    cout << "Все перестановки res = ";
+    printVectorMatrix(res);
+
+    return 0;
+}

ru/codes/cpp/chapter_backtracking/permutations_ii.cpp

@@ -0,0 +1,56 @@
+/**
+ * File: permutations_ii.cpp
+ * Created Time: 2023-04-24
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Алгоритм бэктрекинга: все перестановки II */
+void backtrack(vector<int> &state, const vector<int> &choices, vector<bool> &selected, vector<vector<int>> &res) {
+    // Когда длина состояния равна числу элементов, записать решение
+    if (state.size() == choices.size()) {
+        res.push_back(state);
+        return;
+    }
+    // Перебор всех вариантов выбора
+    unordered_set<int> duplicated;
+    for (int i = 0; i < choices.size(); i++) {
+        int choice = choices[i];
+        // Отсечение: нельзя выбирать один и тот же элемент повторно и нельзя повторно выбирать равные элементы
+        if (!selected[i] && duplicated.find(choice) == duplicated.end()) {
+            // Попытка: сделать выбор и обновить состояние
+            duplicated.emplace(choice); // Записать значения уже выбранных элементов
+            selected[i] = true;
+            state.push_back(choice);
+            // Перейти к следующему выбору
+            backtrack(state, choices, selected, res);
+            // Откат: отменить выбор и восстановить предыдущее состояние
+            selected[i] = false;
+            state.pop_back();
+        }
+    }
+}
+
+/* Все перестановки II */
+vector<vector<int>> permutationsII(vector<int> nums) {
+    vector<int> state;
+    vector<bool> selected(nums.size(), false);
+    vector<vector<int>> res;
+    backtrack(state, nums, selected, res);
+    return res;
+}
+
+/* Driver Code */
+int main() {
+    vector<int> nums = {1, 1, 2};
+
+    vector<vector<int>> res = permutationsII(nums);
+
+    cout << "Входной массив nums = ";
+    printVector(nums);
+    cout << "Все перестановки res = ";
+    printVectorMatrix(res);
+
+    return 0;
+}

ru/codes/cpp/chapter_backtracking/preorder_traversal_i_compact.cpp

@@ -0,0 +1,39 @@
+/**
+ * File: preorder_traversal_i_compact.cpp
+ * Created Time: 2023-04-16
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+vector<TreeNode *> res;
+
+/* Предварительный обход: пример 1 */
+void preOrder(TreeNode *root) {
+    if (root == nullptr) {
+        return;
+    }
+    if (root->val == 7) {
+        // Записать решение
+        res.push_back(root);
+    }
+    preOrder(root->left);
+    preOrder(root->right);
+}
+
+/* Driver Code */
+int main() {
+    TreeNode *root = vectorToTree(vector<int>{1, 7, 3, 4, 5, 6, 7});
+    cout << "\nИнициализация двоичного дерева" << endl;
+    printTree(root);
+
+    // Предварительный обход
+    preOrder(root);
+
+    cout << "\nВывести все узлы со значением 7" << endl;
+    vector<int> vals;
+    for (TreeNode *node : res) {
+        vals.push_back(node->val);
+    }
+    printVector(vals);
+}

ru/codes/cpp/chapter_backtracking/preorder_traversal_ii_compact.cpp

@@ -0,0 +1,46 @@
+/**
+ * File: preorder_traversal_ii_compact.cpp
+ * Created Time: 2023-04-16
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+vector<TreeNode *> path;
+vector<vector<TreeNode *>> res;
+
+/* Предварительный обход: пример 2 */
+void preOrder(TreeNode *root) {
+    if (root == nullptr) {
+        return;
+    }
+    // Попытка
+    path.push_back(root);
+    if (root->val == 7) {
+        // Записать решение
+        res.push_back(path);
+    }
+    preOrder(root->left);
+    preOrder(root->right);
+    // Откат
+    path.pop_back();
+}
+
+/* Driver Code */
+int main() {
+    TreeNode *root = vectorToTree(vector<int>{1, 7, 3, 4, 5, 6, 7});
+    cout << "\nИнициализация двоичного дерева" << endl;
+    printTree(root);
+
+    // Предварительный обход
+    preOrder(root);
+
+    cout << "\nВывести все пути от корня к узлу 7" << endl;
+    for (vector<TreeNode *> &path : res) {
+        vector<int> vals;
+        for (TreeNode *node : path) {
+            vals.push_back(node->val);
+        }
+        printVector(vals);
+    }
+}

ru/codes/cpp/chapter_backtracking/preorder_traversal_iii_compact.cpp

@@ -0,0 +1,47 @@
+/**
+ * File: preorder_traversal_iii_compact.cpp
+ * Created Time: 2023-04-16
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+vector<TreeNode *> path;
+vector<vector<TreeNode *>> res;
+
+/* Предварительный обход: пример 3 */
+void preOrder(TreeNode *root) {
+    // Отсечение
+    if (root == nullptr || root->val == 3) {
+        return;
+    }
+    // Попытка
+    path.push_back(root);
+    if (root->val == 7) {
+        // Записать решение
+        res.push_back(path);
+    }
+    preOrder(root->left);
+    preOrder(root->right);
+    // Откат
+    path.pop_back();
+}
+
+/* Driver Code */
+int main() {
+    TreeNode *root = vectorToTree(vector<int>{1, 7, 3, 4, 5, 6, 7});
+    cout << "\nИнициализация двоичного дерева" << endl;
+    printTree(root);
+
+    // Предварительный обход
+    preOrder(root);
+
+    cout << "\nВывести все пути от корня к узлу 7, не содержащие узлов со значением 3" << endl;
+    for (vector<TreeNode *> &path : res) {
+        vector<int> vals;
+        for (TreeNode *node : path) {
+            vals.push_back(node->val);
+        }
+        printVector(vals);
+    }
+}

ru/codes/cpp/chapter_backtracking/preorder_traversal_iii_template.cpp

@@ -0,0 +1,76 @@
+/**
+ * File: preorder_traversal_iii_template.cpp
+ * Created Time: 2023-04-16
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Проверить, является ли текущее состояние решением */
+bool isSolution(vector<TreeNode *> &state) {
+    return !state.empty() && state.back()->val == 7;
+}
+
+/* Записать решение */
+void recordSolution(vector<TreeNode *> &state, vector<vector<TreeNode *>> &res) {
+    res.push_back(state);
+}
+
+/* Проверить, допустим ли этот выбор в текущем состоянии */
+bool isValid(vector<TreeNode *> &state, TreeNode *choice) {
+    return choice != nullptr && choice->val != 3;
+}
+
+/* Обновить состояние */
+void makeChoice(vector<TreeNode *> &state, TreeNode *choice) {
+    state.push_back(choice);
+}
+
+/* Восстановить состояние */
+void undoChoice(vector<TreeNode *> &state, TreeNode *choice) {
+    state.pop_back();
+}
+
+/* Алгоритм бэктрекинга: пример 3 */
+void backtrack(vector<TreeNode *> &state, vector<TreeNode *> &choices, vector<vector<TreeNode *>> &res) {
+    // Проверить, является ли текущее состояние решением
+    if (isSolution(state)) {
+        // Записать решение
+        recordSolution(state, res);
+    }
+    // Перебор всех вариантов выбора
+    for (TreeNode *choice : choices) {
+        // Отсечение: проверить допустимость выбора
+        if (isValid(state, choice)) {
+            // Попытка: сделать выбор и обновить состояние
+            makeChoice(state, choice);
+            // Перейти к следующему выбору
+            vector<TreeNode *> nextChoices{choice->left, choice->right};
+            backtrack(state, nextChoices, res);
+            // Откат: отменить выбор и восстановить предыдущее состояние
+            undoChoice(state, choice);
+        }
+    }
+}
+
+/* Driver Code */
+int main() {
+    TreeNode *root = vectorToTree(vector<int>{1, 7, 3, 4, 5, 6, 7});
+    cout << "\nИнициализация двоичного дерева" << endl;
+    printTree(root);
+
+    // Алгоритм бэктрекинга
+    vector<TreeNode *> state;
+    vector<TreeNode *> choices = {root};
+    vector<vector<TreeNode *>> res;
+    backtrack(state, choices, res);
+
+    cout << "\nВывести все пути от корня к узлу 7, не содержащие узлов со значением 3" << endl;
+    for (vector<TreeNode *> &path : res) {
+        vector<int> vals;
+        for (TreeNode *node : path) {
+            vals.push_back(node->val);
+        }
+        printVector(vals);
+    }
+}

ru/codes/cpp/chapter_backtracking/subset_sum_i.cpp

@@ -0,0 +1,57 @@
+/**
+ * File: subset_sum_i.cpp
+ * Created Time: 2023-06-21
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Алгоритм бэктрекинга: сумма подмножеств I */
+void backtrack(vector<int> &state, int target, vector<int> &choices, int start, vector<vector<int>> &res) {
+    // Если сумма подмножества равна target, записать решение
+    if (target == 0) {
+        res.push_back(state);
+        return;
+    }
+    // Обойти все варианты выбора
+    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств
+    for (int i = start; i < choices.size(); i++) {
+        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл
+        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target
+        if (target - choices[i] < 0) {
+            break;
+        }
+        // Попытка: сделать выбор и обновить target и start
+        state.push_back(choices[i]);
+        // Перейти к следующему выбору
+        backtrack(state, target - choices[i], choices, i, res);
+        // Откат: отменить выбор и восстановить предыдущее состояние
+        state.pop_back();
+    }
+}
+
+/* Решить задачу суммы подмножеств I */
+vector<vector<int>> subsetSumI(vector<int> &nums, int target) {
+    vector<int> state;              // Состояние (подмножество)
+    sort(nums.begin(), nums.end()); // Отсортировать nums
+    int start = 0;                  // Стартовая вершина обхода
+    vector<vector<int>> res;        // Список результатов (список подмножеств)
+    backtrack(state, target, nums, start, res);
+    return res;
+}
+
+/* Driver Code */
+int main() {
+    vector<int> nums = {3, 4, 5};
+    int target = 9;
+
+    vector<vector<int>> res = subsetSumI(nums, target);
+
+    cout << "Входной массив nums = ";
+    printVector(nums);
+    cout << "target = " << target << endl;
+    cout << "Все подмножества с суммой " << target << ": " << endl;
+    printVectorMatrix(res);
+
+    return 0;
+}

ru/codes/cpp/chapter_backtracking/subset_sum_i_naive.cpp

@@ -0,0 +1,54 @@
+/**
+ * File: subset_sum_i_naive.cpp
+ * Created Time: 2023-06-21
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Алгоритм бэктрекинга: сумма подмножеств I */
+void backtrack(vector<int> &state, int target, int total, vector<int> &choices, vector<vector<int>> &res) {
+    // Если сумма подмножества равна target, записать решение
+    if (total == target) {
+        res.push_back(state);
+        return;
+    }
+    // Перебор всех вариантов выбора
+    for (size_t i = 0; i < choices.size(); i++) {
+        // Отсечение: если сумма подмножества превышает target, пропустить этот выбор
+        if (total + choices[i] > target) {
+            continue;
+        }
+        // Попытка: сделать выбор и обновить элемент и total
+        state.push_back(choices[i]);
+        // Перейти к следующему выбору
+        backtrack(state, target, total + choices[i], choices, res);
+        // Откат: отменить выбор и восстановить предыдущее состояние
+        state.pop_back();
+    }
+}
+
+/* Решить задачу суммы подмножеств I (с повторяющимися подмножествами) */
+vector<vector<int>> subsetSumINaive(vector<int> &nums, int target) {
+    vector<int> state;       // Состояние (подмножество)
+    int total = 0;           // Сумма подмножеств
+    vector<vector<int>> res; // Список результатов (список подмножеств)
+    backtrack(state, target, total, nums, res);
+    return res;
+}
+
+/* Driver Code */
+int main() {
+    vector<int> nums = {3, 4, 5};
+    int target = 9;
+
+    vector<vector<int>> res = subsetSumINaive(nums, target);
+
+    cout << "Входной массив nums = ";
+    printVector(nums);
+    cout << "target = " << target << endl;
+    cout << "Все подмножества с суммой " << target << ": " << endl;
+    printVectorMatrix(res);
+
+    return 0;
+}

ru/codes/cpp/chapter_backtracking/subset_sum_ii.cpp

@@ -0,0 +1,62 @@
+/**
+ * File: subset_sum_ii.cpp
+ * Created Time: 2023-06-21
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Алгоритм бэктрекинга: сумма подмножеств II */
+void backtrack(vector<int> &state, int target, vector<int> &choices, int start, vector<vector<int>> &res) {
+    // Если сумма подмножества равна target, записать решение
+    if (target == 0) {
+        res.push_back(state);
+        return;
+    }
+    // Обойти все варианты выбора
+    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств
+    // Отсечение 3: начинать обход с start, чтобы избежать повторного выбора одного и того же элемента
+    for (int i = start; i < choices.size(); i++) {
+        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл
+        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target
+        if (target - choices[i] < 0) {
+            break;
+        }
+        // Отсечение 4: если этот элемент равен элементу слева, значит ветвь поиска повторяется, ее нужно сразу пропустить
+        if (i > start && choices[i] == choices[i - 1]) {
+            continue;
+        }
+        // Попытка: сделать выбор и обновить target и start
+        state.push_back(choices[i]);
+        // Перейти к следующему выбору
+        backtrack(state, target - choices[i], choices, i + 1, res);
+        // Откат: отменить выбор и восстановить предыдущее состояние
+        state.pop_back();
+    }
+}
+
+/* Решить задачу суммы подмножеств II */
+vector<vector<int>> subsetSumII(vector<int> &nums, int target) {
+    vector<int> state;              // Состояние (подмножество)
+    sort(nums.begin(), nums.end()); // Отсортировать nums
+    int start = 0;                  // Стартовая вершина обхода
+    vector<vector<int>> res;        // Список результатов (список подмножеств)
+    backtrack(state, target, nums, start, res);
+    return res;
+}
+
+/* Driver Code */
+int main() {
+    vector<int> nums = {4, 4, 5};
+    int target = 9;
+
+    vector<vector<int>> res = subsetSumII(nums, target);
+
+    cout << "Входной массив nums = ";
+    printVector(nums);
+    cout << "target = " << target << endl;
+    cout << "Все подмножества с суммой " << target << ": " << endl;
+    printVectorMatrix(res);
+
+    return 0;
+}

ru/codes/cpp/chapter_computational_complexity/CMakeLists.txt

@@ -0,0 +1,5 @@
+add_executable(iteration iteration.cpp)
+add_executable(recursion recursion.cpp)
+add_executable(space_complexity space_complexity.cpp)
+add_executable(time_complexity time_complexity.cpp)
+add_executable(worst_best_time_complexity worst_best_time_complexity.cpp)

ru/codes/cpp/chapter_computational_complexity/iteration.cpp

@@ -0,0 +1,76 @@
+/**
+ * File: iteration.cpp
+ * Created Time: 2023-08-24
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Цикл for */
+int forLoop(int n) {
+    int res = 0;
+    // Циклическое суммирование 1, 2, ..., n-1, n
+    for (int i = 1; i <= n; ++i) {
+        res += i;
+    }
+    return res;
+}
+
+/* Цикл while */
+int whileLoop(int n) {
+    int res = 0;
+    int i = 1; // Инициализация условной переменной
+    // Циклическое суммирование 1, 2, ..., n-1, n
+    while (i <= n) {
+        res += i;
+        i++; // Обновить условную переменную
+    }
+    return res;
+}
+
+/* Цикл while (двойное обновление) */
+int whileLoopII(int n) {
+    int res = 0;
+    int i = 1; // Инициализация условной переменной
+    // Циклическое суммирование 1, 4, 10, ...
+    while (i <= n) {
+        res += i;
+        // Обновить условную переменную
+        i++;
+        i *= 2;
+    }
+    return res;
+}
+
+/* Двойной цикл for */
+string nestedForLoop(int n) {
+    ostringstream res;
+    // Цикл по 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 << "(" << i << ", " << j << "), ";
+        }
+    }
+    return res.str();
+}
+
+/* Driver Code */
+int main() {
+    int n = 5;
+    int res;
+
+    res = forLoop(n);
+    cout << "\nРезультат суммирования в цикле for res = " << res << endl;
+
+    res = whileLoop(n);
+    cout << "\nРезультат суммирования в цикле while res = " << res << endl;
+
+    res = whileLoopII(n);
+    cout << "\nРезультат суммирования в цикле while (двойное обновление) res = " << res << endl;
+
+    string resStr = nestedForLoop(n);
+    cout << "\nРезультат двойного цикла for " << resStr << endl;
+
+    return 0;
+}

ru/codes/cpp/chapter_computational_complexity/recursion.cpp

@@ -0,0 +1,78 @@
+/**
+ * File: recursion.cpp
+ * Created Time: 2023-08-24
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Рекурсия */
+int recur(int n) {
+    // Условие завершения
+    if (n == 1)
+        return 1;
+    // Рекурсия: рекурсивный вызов
+    int res = recur(n - 1);
+    // Возврат: вернуть результат
+    return n + res;
+}
+
+/* Имитация рекурсии итерацией */
+int forLoopRecur(int n) {
+    // Использовать явный стек для имитации системного стека вызовов
+    stack<int> stack;
+    int res = 0;
+    // Рекурсия: рекурсивный вызов
+    for (int i = n; i > 0; i--) {
+        // Имитировать «рекурсию» с помощью операции помещения в стек
+        stack.push(i);
+    }
+    // Возврат: вернуть результат
+    while (!stack.empty()) {
+        // Имитировать «возврат» с помощью операции извлечения из стека
+        res += stack.top();
+        stack.pop();
+    }
+    // res = 1+2+3+...+n
+    return res;
+}
+
+/* Хвостовая рекурсия */
+int tailRecur(int n, int res) {
+    // Условие завершения
+    if (n == 0)
+        return res;
+    // Хвостовой рекурсивный вызов
+    return tailRecur(n - 1, res + n);
+}
+
+/* Последовательность Фибоначчи: рекурсия */
+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 */
+int main() {
+    int n = 5;
+    int res;
+
+    res = recur(n);
+    cout << "\nРезультат суммирования в рекурсивной функции res = " << res << endl;
+
+    res = forLoopRecur(n);
+    cout << "\nРезультат суммирования с использованием итерации для имитации рекурсии res = " << res << endl;
+
+    res = tailRecur(n, 0);
+    cout << "\nРезультат суммирования в хвостовой рекурсии res = " << res << endl;
+
+    res = fib(n);
+    cout << "\nЭлемент последовательности Фибоначчи с индексом " << n << " = " << res << endl;
+
+    return 0;
+}

ru/codes/cpp/chapter_computational_complexity/space_complexity.cpp

@@ -0,0 +1,107 @@
+/**
+ * File: space_complexity.cpp
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Функция */
+int func() {
+    // Выполнить некоторые операции
+    return 0;
+}
+
+/* Постоянная сложность */
+void constant(int n) {
+    // Константы, переменные и объекты занимают O(1) памяти
+    const int a = 0;
+    int b = 0;
+    vector<int> nums(10000);
+    ListNode node(0);
+    // Переменные в цикле занимают O(1) памяти
+    for (int i = 0; i < n; i++) {
+        int c = 0;
+    }
+    // Функции в цикле занимают O(1) памяти
+    for (int i = 0; i < n; i++) {
+        func();
+    }
+}
+
+/* Линейная сложность */
+void linear(int n) {
+    // Массив длины n занимает O(n) памяти
+    vector<int> nums(n);
+    // Список длины n занимает O(n) памяти
+    vector<ListNode> nodes;
+    for (int i = 0; i < n; i++) {
+        nodes.push_back(ListNode(i));
+    }
+    // Хеш-таблица длины n занимает O(n) памяти
+    unordered_map<int, string> map;
+    for (int i = 0; i < n; i++) {
+        map[i] = to_string(i);
+    }
+}
+
+/* Линейная сложность (рекурсивная реализация) */
+void linearRecur(int n) {
+    cout << "Рекурсия n = " << n << endl;
+    if (n == 1)
+        return;
+    linearRecur(n - 1);
+}
+
+/* Квадратичная сложность */
+void quadratic(int n) {
+    // Двумерный список занимает O(n^2) памяти
+    vector<vector<int>> numMatrix;
+    for (int i = 0; i < n; i++) {
+        vector<int> tmp;
+        for (int j = 0; j < n; j++) {
+            tmp.push_back(0);
+        }
+        numMatrix.push_back(tmp);
+    }
+}
+
+/* Квадратичная сложность (рекурсивная реализация) */
+int quadraticRecur(int n) {
+    if (n <= 0)
+        return 0;
+    vector<int> nums(n);
+    cout << "Рекурсия n = " << n << " , длина nums = " << nums.size() << endl;
+    return quadraticRecur(n - 1);
+}
+
+/* Экспоненциальная сложность (построение полного двоичного дерева) */
+TreeNode *buildTree(int n) {
+    if (n == 0)
+        return nullptr;
+    TreeNode *root = new TreeNode(0);
+    root->left = buildTree(n - 1);
+    root->right = buildTree(n - 1);
+    return root;
+}
+
+/* Driver Code */
+int main() {
+    int n = 5;
+    // Постоянная сложность
+    constant(n);
+    // Линейная сложность
+    linear(n);
+    linearRecur(n);
+    // Квадратичная сложность
+    quadratic(n);
+    quadraticRecur(n);
+    // Экспоненциальная сложность
+    TreeNode *root = buildTree(n);
+    printTree(root);
+
+    // Освободить память
+    freeMemoryTree(root);
+
+    return 0;
+}

ru/codes/cpp/chapter_computational_complexity/time_complexity.cpp

@@ -0,0 +1,168 @@
+/**
+ * File: time_complexity.cpp
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Постоянная сложность */
+int constant(int n) {
+    int count = 0;
+    int size = 100000;
+    for (int i = 0; i < size; i++)
+        count++;
+    return count;
+}
+
+/* Линейная сложность */
+int linear(int n) {
+    int count = 0;
+    for (int i = 0; i < n; i++)
+        count++;
+    return count;
+}
+
+/* Линейная сложность (обход массива) */
+int arrayTraversal(vector<int> &nums) {
+    int count = 0;
+    // Число итераций пропорционально длине массива
+    for (int num : nums) {
+        count++;
+    }
+    return count;
+}
+
+/* Квадратичная сложность */
+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;
+}
+
+/* Квадратичная сложность (пузырьковая сортировка) */
+int bubbleSort(vector<int> &nums) {
+    int count = 0; // Счетчик
+    // Внешний цикл: неотсортированный диапазон [0, i]
+    for (int i = nums.size() - 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;
+}
+
+/* Экспоненциальная сложность (итеративная реализация) */
+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;
+}
+
+/* Экспоненциальная сложность (рекурсивная реализация) */
+int expRecur(int n) {
+    if (n == 1)
+        return 1;
+    return expRecur(n - 1) + expRecur(n - 1) + 1;
+}
+
+/* Логарифмическая сложность (итеративная реализация) */
+int logarithmic(int n) {
+    int count = 0;
+    while (n > 1) {
+        n = n / 2;
+        count++;
+    }
+    return count;
+}
+
+/* Логарифмическая сложность (рекурсивная реализация) */
+int logRecur(int n) {
+    if (n <= 1)
+        return 0;
+    return logRecur(n / 2) + 1;
+}
+
+/* Линейно-логарифмическая сложность */
+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;
+}
+
+/* Факториальная сложность (рекурсивная реализация) */
+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 */
+int main() {
+    // Можно изменить n и запустить программу, чтобы увидеть, как меняется число операций при разных сложностях
+    int n = 8;
+    cout << "Размер входных данных n = " << n << endl;
+
+    int count = constant(n);
+    cout << "Количество операций постоянной сложности = " << count << endl;
+
+    count = linear(n);
+    cout << "Количество операций линейной сложности = " << count << endl;
+    vector<int> arr(n);
+    count = arrayTraversal(arr);
+    cout << "Количество операций линейной сложности (обход массива) = " << count << endl;
+
+    count = quadratic(n);
+    cout << "Количество операций квадратичной сложности = " << count << endl;
+    vector<int> nums(n);
+    for (int i = 0; i < n; i++)
+        nums[i] = n - i; // [n,n-1,...,2,1]
+    count = bubbleSort(nums);
+    cout << "Количество операций квадратичной сложности (пузырьковая сортировка) = " << count << endl;
+
+    count = exponential(n);
+    cout << "Количество операций экспоненциальной сложности (итерация) = " << count << endl;
+    count = expRecur(n);
+    cout << "Количество операций экспоненциальной сложности (рекурсия) = " << count << endl;
+
+    count = logarithmic(n);
+    cout << "Количество операций логарифмической сложности (итерация) = " << count << endl;
+    count = logRecur(n);
+    cout << "Количество операций логарифмической сложности (рекурсия) = " << count << endl;
+
+    count = linearLogRecur(n);
+    cout << "Количество операций линейно-логарифмической сложности (рекурсия) = " << count << endl;
+
+    count = factorialRecur(n);
+    cout << "Количество операций факториальной сложности (рекурсия) = " << count << endl;
+
+    return 0;
+}

ru/codes/cpp/chapter_computational_complexity/worst_best_time_complexity.cpp

@@ -0,0 +1,45 @@
+/**
+ * File: worst_best_time_complexity.cpp
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Создать массив с элементами { 1, 2, ..., n } в случайном порядке */
+vector<int> randomNumbers(int n) {
+    vector<int> nums(n);
+    // Создать массив nums = { 1, 2, 3, ..., n }
+    for (int i = 0; i < n; i++) {
+        nums[i] = i + 1;
+    }
+    // Использовать системное время для генерации случайного seed
+    unsigned seed = chrono::system_clock::now().time_since_epoch().count();
+    // Случайно перемешать элементы массива
+    shuffle(nums.begin(), nums.end(), default_random_engine(seed));
+    return nums;
+}
+
+/* Найти индекс числа 1 в массиве nums */
+int findOne(vector<int> &nums) {
+    for (int i = 0; i < nums.size(); i++) {
+        // Когда элемент 1 находится в начале массива, достигается лучшая временная сложность O(1)
+        // Когда элемент 1 находится в конце массива, достигается худшая временная сложность O(n)
+        if (nums[i] == 1)
+            return i;
+    }
+    return -1;
+}
+
+/* Driver Code */
+int main() {
+    for (int i = 0; i < 1000; i++) {
+        int n = 100;
+        vector<int> nums = randomNumbers(n);
+        int index = findOne(nums);
+        cout << "\nПосле перемешивания массива [ 1, 2, ..., n ] nums = ";
+        printVector(nums);
+        cout << "Индекс числа 1 = " << index << endl;
+    }
+    return 0;
+}

ru/codes/cpp/chapter_divide_and_conquer/CMakeLists.txt

@@ -0,0 +1,3 @@
+add_executable(binary_search_recur binary_search_recur.cpp)
+add_executable(build_tree build_tree.cpp)
+add_executable(hanota hanota.cpp)

ru/codes/cpp/chapter_divide_and_conquer/binary_search_recur.cpp

@@ -0,0 +1,46 @@
+/**
+ * File: binary_search_recur.cpp
+ * Created Time: 2023-07-17
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Бинарный поиск: задача f(i, j) */
+int dfs(vector<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;
+    }
+}
+
+/* Бинарный поиск */
+int binarySearch(vector<int> &nums, int target) {
+    int n = nums.size();
+    // Решить задачу f(0, n-1)
+    return dfs(nums, target, 0, n - 1);
+}
+
+/* Driver Code */
+int main() {
+    int target = 6;
+    vector<int> nums = {1, 3, 6, 8, 12, 15, 23, 26, 31, 35};
+
+    // Бинарный поиск (двусторонне замкнутый интервал)
+    int index = binarySearch(nums, target);
+    cout << "Индекс целевого элемента 6 = " << index << endl;
+
+    return 0;
+}

ru/codes/cpp/chapter_divide_and_conquer/build_tree.cpp

@@ -0,0 +1,51 @@
+/**
+ * File: build_tree.cpp
+ * Created Time: 2023-07-17
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Построить двоичное дерево: разделяй и властвуй */
+TreeNode *dfs(vector<int> &preorder, unordered_map<int, int> &inorderMap, int i, int l, int r) {
+    // Завершить при пустом диапазоне поддерева
+    if (r - l < 0)
+        return NULL;
+    // Инициализировать корневой узел
+    TreeNode *root = new TreeNode(preorder[i]);
+    // Найти m, чтобы разделить левое и правое поддеревья
+    int m = inorderMap[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;
+}
+
+/* Построить двоичное дерево */
+TreeNode *buildTree(vector<int> &preorder, vector<int> &inorder) {
+    // Инициализировать хеш-таблицу для хранения соответствия элементов inorder их индексам
+    unordered_map<int, int> inorderMap;
+    for (int i = 0; i < inorder.size(); i++) {
+        inorderMap[inorder[i]] = i;
+    }
+    TreeNode *root = dfs(preorder, inorderMap, 0, 0, inorder.size() - 1);
+    return root;
+}
+
+/* Driver Code */
+int main() {
+    vector<int> preorder = {3, 9, 2, 1, 7};
+    vector<int> inorder = {9, 3, 1, 2, 7};
+    cout << "Предварительный обход = ";
+    printVector(preorder);
+    cout << "Симметричный обход = ";
+    printVector(inorder);
+
+    TreeNode *root = buildTree(preorder, inorder);
+    cout << "Построенное двоичное дерево:\n";
+    printTree(root);
+
+    return 0;
+}

ru/codes/cpp/chapter_divide_and_conquer/hanota.cpp

@@ -0,0 +1,66 @@
+/**
+ * File: hanota.cpp
+ * Created Time: 2023-07-17
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Переместить один диск */
+void move(vector<int> &src, vector<int> &tar) {
+    // Снять диск с вершины src
+    int pan = src.back();
+    src.pop_back();
+    // Положить диск на вершину tar
+    tar.push_back(pan);
+}
+
+/* Решить задачу Ханойской башни f(i) */
+void dfs(int i, vector<int> &src, vector<int> &buf, vector<int> &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);
+}
+
+/* Решить задачу Ханойской башни */
+void solveHanota(vector<int> &A, vector<int> &B, vector<int> &C) {
+    int n = A.size();
+    // Переместить верхние n дисков из A в C с помощью B
+    dfs(n, A, B, C);
+}
+
+/* Driver Code */
+int main() {
+    // Хвост списка соответствует вершине столбца
+    vector<int> A = {5, 4, 3, 2, 1};
+    vector<int> B = {};
+    vector<int> C = {};
+
+    cout << "Начальное состояние:\n";
+    cout << "A =";
+    printVector(A);
+    cout << "B =";
+    printVector(B);
+    cout << "C =";
+    printVector(C);
+
+    solveHanota(A, B, C);
+
+    cout << "После завершения перемещения дисков:\n";
+    cout << "A =";
+    printVector(A);
+    cout << "B =";
+    printVector(B);
+    cout << "C =";
+    printVector(C);
+
+    return 0;
+}

ru/codes/cpp/chapter_dynamic_programming/CMakeLists.txt

@@ -0,0 +1,10 @@
+add_executable(climbing_stairs_backtrack climbing_stairs_backtrack.cpp)
+add_executable(climbing_stairs_dfs climbing_stairs_dfs.cpp)
+add_executable(climbing_stairs_dfs_mem climbing_stairs_dfs_mem.cpp)
+add_executable(climbing_stairs_dp climbing_stairs_dp.cpp)
+add_executable(min_cost_climbing_stairs_dp min_cost_climbing_stairs_dp.cpp)
+add_executable(min_path_sum min_path_sum.cpp)
+add_executable(unbounded_knapsack unbounded_knapsack.cpp)
+add_executable(coin_change coin_change.cpp)
+add_executable(coin_change_ii coin_change_ii.cpp)
+add_executable(edit_distance edit_distance.cpp)

ru/codes/cpp/chapter_dynamic_programming/climbing_stairs_backtrack.cpp

@@ -0,0 +1,43 @@
+
+/**
+ * File: climbing_stairs_backtrack.cpp
+ * Created Time: 2023-06-30
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Бэктрекинг */
+void backtrack(vector<int> &choices, int state, int n, vector<int> &res) {
+    // Когда подъем достигает n-й ступени, число вариантов увеличивается на 1
+    if (state == n)
+        res[0]++;
+    // Перебор всех вариантов выбора
+    for (auto &choice : choices) {
+        // Отсечение: нельзя выходить за n-ю ступень
+        if (state + choice > n)
+            continue;
+        // Попытка: сделать выбор и обновить состояние
+        backtrack(choices, state + choice, n, res);
+        // Откат
+    }
+}
+
+/* Подъем по лестнице: бэктрекинг */
+int climbingStairsBacktrack(int n) {
+    vector<int> choices = {1, 2}; // Можно подняться на 1 или 2 ступени
+    int state = 0;                // Начать подъем с 0-й ступени
+    vector<int> res = {0};        // Использовать res[0] для хранения числа решений
+    backtrack(choices, state, n, res);
+    return res[0];
+}
+
+/* Driver Code */
+int main() {
+    int n = 9;
+
+    int res = climbingStairsBacktrack(n);
+    cout << "Количество способов подняться по лестнице из " << n << " ступеней: " << res << " вариантов" << endl;
+
+    return 0;
+}

ru/codes/cpp/chapter_dynamic_programming/climbing_stairs_constraint_dp.cpp

@@ -0,0 +1,37 @@
+/**
+ * File: climbing_stairs_constraint_dp.cpp
+ * Created Time: 2023-07-01
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Подъем по лестнице с ограничениями: динамическое программирование */
+int climbingStairsConstraintDP(int n) {
+    if (n == 1 || n == 2) {
+        return 1;
+    }
+    // Инициализация таблицы dp для хранения решений подзадач
+    vector<vector<int>> dp(n + 1, vector<int>(3, 0));
+    // Начальное состояние: заранее задать решения наименьших подзадач
+    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];
+}
+
+/* Driver Code */
+int main() {
+    int n = 9;
+
+    int res = climbingStairsConstraintDP(n);
+    cout << "Количество способов подняться по лестнице из " << n << " ступеней: " << res << " вариантов" << endl;
+
+    return 0;
+}

ru/codes/cpp/chapter_dynamic_programming/climbing_stairs_dfs.cpp

@@ -0,0 +1,32 @@
+/**
+ * File: climbing_stairs_dfs.cpp
+ * Created Time: 2023-06-30
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Поиск */
+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;
+}
+
+/* Подъем по лестнице: поиск */
+int climbingStairsDFS(int n) {
+    return dfs(n);
+}
+
+/* Driver Code */
+int main() {
+    int n = 9;
+
+    int res = climbingStairsDFS(n);
+    cout << "Количество способов подняться по лестнице из " << n << " ступеней: " << res << " вариантов" << endl;
+
+    return 0;
+}

ru/codes/cpp/chapter_dynamic_programming/climbing_stairs_dfs_mem.cpp

@@ -0,0 +1,39 @@
+/**
+ * File: climbing_stairs_dfs_mem.cpp
+ * Created Time: 2023-06-30
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Поиск с мемоизацией */
+int dfs(int i, vector<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;
+}
+
+/* Подъем по лестнице: поиск с мемоизацией */
+int climbingStairsDFSMem(int n) {
+    // mem[i] хранит число способов подняться на i-ю ступень, -1 означает отсутствие записи
+    vector<int> mem(n + 1, -1);
+    return dfs(n, mem);
+}
+
+/* Driver Code */
+int main() {
+    int n = 9;
+
+    int res = climbingStairsDFSMem(n);
+    cout << "Количество способов подняться по лестнице из " << n << " ступеней: " << res << " вариантов" << endl;
+
+    return 0;
+}

ru/codes/cpp/chapter_dynamic_programming/climbing_stairs_dp.cpp

@@ -0,0 +1,49 @@
+/**
+ * File: climbing_stairs_dp.cpp
+ * Created Time: 2023-06-30
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Подъем по лестнице: динамическое программирование */
+int climbingStairsDP(int n) {
+    if (n == 1 || n == 2)
+        return n;
+    // Инициализация таблицы dp для хранения решений подзадач
+    vector<int> dp(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];
+}
+
+/* Подъем по лестнице: динамическое программирование с оптимизацией памяти */
+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;
+}
+
+/* Driver Code */
+int main() {
+    int n = 9;
+
+    int res = climbingStairsDP(n);
+    cout << "Количество способов подняться по лестнице из " << n << " ступеней: " << res << " вариантов" << endl;
+
+    res = climbingStairsDPComp(n);
+    cout << "Количество способов подняться по лестнице из " << n << " ступеней: " << res << " вариантов" << endl;
+
+    return 0;
+}

ru/codes/cpp/chapter_dynamic_programming/coin_change.cpp

@@ -0,0 +1,70 @@
+/**
+ * File: coin_change.cpp
+ * Created Time: 2023-07-11
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Размен монет: динамическое программирование */
+int coinChangeDP(vector<int> &coins, int amt) {
+    int n = coins.size();
+    int MAX = amt + 1;
+    // Инициализация таблицы dp
+    vector<vector<int>> dp(n + 1, vector<int>(amt + 1, 0));
+    // Переход состояний: первая строка и первый столбец
+    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] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);
+            }
+        }
+    }
+    return dp[n][amt] != MAX ? dp[n][amt] : -1;
+}
+
+/* Размен монет: динамическое программирование с оптимизацией памяти */
+int coinChangeDPComp(vector<int> &coins, int amt) {
+    int n = coins.size();
+    int MAX = amt + 1;
+    // Инициализация таблицы dp
+    vector<int> dp(amt + 1, 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] = min(dp[a], dp[a - coins[i - 1]] + 1);
+            }
+        }
+    }
+    return dp[amt] != MAX ? dp[amt] : -1;
+}
+
+/* Driver code */
+int main() {
+    vector<int> coins = {1, 2, 5};
+    int amt = 4;
+
+    // Динамическое программирование
+    int res = coinChangeDP(coins, amt);
+    cout << "Минимальное количество монет для целевой суммы = " << res << endl;
+
+    // Динамическое программирование с оптимизацией памяти
+    res = coinChangeDPComp(coins, amt);
+    cout << "Минимальное количество монет для целевой суммы = " << res << endl;
+
+    return 0;
+}

ru/codes/cpp/chapter_dynamic_programming/coin_change_ii.cpp

@@ -0,0 +1,68 @@
+/**
+ * File: coin_change_ii.cpp
+ * Created Time: 2023-07-11
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Размен монет II: динамическое программирование */
+int coinChangeIIDP(vector<int> &coins, int amt) {
+    int n = coins.size();
+    // Инициализация таблицы dp
+    vector<vector<int>> dp(n + 1, vector<int>(amt + 1, 0));
+    // Инициализация первого столбца
+    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: динамическое программирование с оптимизацией памяти */
+int coinChangeIIDPComp(vector<int> &coins, int amt) {
+    int n = coins.size();
+    // Инициализация таблицы dp
+    vector<int> dp(amt + 1, 0);
+    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];
+}
+
+/* Driver code */
+int main() {
+    vector<int> coins = {1, 2, 5};
+    int amt = 5;
+
+    // Динамическое программирование
+    int res = coinChangeIIDP(coins, amt);
+    cout << "Количество комбинаций монет для набора целевой суммы = " << res << endl;
+
+    // Динамическое программирование с оптимизацией памяти
+    res = coinChangeIIDPComp(coins, amt);
+    cout << "Количество комбинаций монет для набора целевой суммы = " << res << endl;
+
+    return 0;
+}

ru/codes/cpp/chapter_dynamic_programming/edit_distance.cpp

@@ -0,0 +1,136 @@
+/**
+ * File: edit_distance.cpp
+ * Created Time: 2023-07-13
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Редакционное расстояние: полный перебор */
+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[i - 1] == t[j - 1])
+        return editDistanceDFS(s, t, i - 1, j - 1);
+    // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1
+    int insert = editDistanceDFS(s, t, i, j - 1);
+    int del = editDistanceDFS(s, t, i - 1, j);
+    int replace = editDistanceDFS(s, t, i - 1, j - 1);
+    // Вернуть минимальное число шагов редактирования
+    return min(min(insert, del), replace) + 1;
+}
+
+/* Редакционное расстояние: поиск с мемоизацией */
+int editDistanceDFSMem(string s, string t, vector<vector<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[i - 1] == t[j - 1])
+        return editDistanceDFSMem(s, t, mem, i - 1, j - 1);
+    // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1
+    int insert = editDistanceDFSMem(s, t, mem, i, j - 1);
+    int del = editDistanceDFSMem(s, t, mem, i - 1, j);
+    int replace = editDistanceDFSMem(s, t, mem, i - 1, j - 1);
+    // Сохранить и вернуть минимальное число шагов редактирования
+    mem[i][j] = min(min(insert, del), replace) + 1;
+    return mem[i][j];
+}
+
+/* Редакционное расстояние: динамическое программирование */
+int editDistanceDP(string s, string t) {
+    int n = s.length(), m = t.length();
+    vector<vector<int>> dp(n + 1, vector<int>(m + 1, 0));
+    // Переход состояний: первая строка и первый столбец
+    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[i - 1] == t[j - 1]) {
+                // Если два символа равны, сразу пропустить их
+                dp[i][j] = dp[i - 1][j - 1];
+            } else {
+                // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1
+                dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;
+            }
+        }
+    }
+    return dp[n][m];
+}
+
+/* Редакционное расстояние: динамическое программирование с оптимизацией памяти */
+int editDistanceDPComp(string s, string t) {
+    int n = s.length(), m = t.length();
+    vector<int> dp(m + 1, 0);
+    // Переход состояний: первая строка
+    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[i - 1] == t[j - 1]) {
+                // Если два символа равны, сразу пропустить их
+                dp[j] = leftup;
+            } else {
+                // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1
+                dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1;
+            }
+            leftup = temp; // Обновить до значения dp[i-1, j-1] для следующей итерации
+        }
+    }
+    return dp[m];
+}
+
+/* Driver Code */
+int main() {
+    string s = "bag";
+    string t = "pack";
+    int n = s.length(), m = t.length();
+
+    // Полный перебор
+    int res = editDistanceDFS(s, t, n, m);
+    cout << "Чтобы заменить " << s << " на " << t << " , требуется минимум " << res << " операций редактирования\n";
+
+    // Поиск с мемоизацией
+    vector<vector<int>> mem(n + 1, vector<int>(m + 1, -1));
+    res = editDistanceDFSMem(s, t, mem, n, m);
+    cout << "Чтобы заменить " << s << " на " << t << " , требуется минимум " << res << " операций редактирования\n";
+
+    // Динамическое программирование
+    res = editDistanceDP(s, t);
+    cout << "Чтобы заменить " << s << " на " << t << " , требуется минимум " << res << " операций редактирования\n";
+
+    // Динамическое программирование с оптимизацией памяти
+    res = editDistanceDPComp(s, t);
+    cout << "Чтобы заменить " << s << " на " << t << " , требуется минимум " << res << " операций редактирования\n";
+
+    return 0;
+}

ru/codes/cpp/chapter_dynamic_programming/knapsack.cpp

@@ -0,0 +1,109 @@
+#include <algorithm>
+#include <iostream>
+#include <vector>
+
+using namespace std;
+
+/* Рюкзак 0-1: полный перебор */
+int knapsackDFS(vector<int> &wgt, vector<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 max(no, yes);
+}
+
+/* Рюкзак 0-1: поиск с мемоизацией */
+int knapsackDFSMem(vector<int> &wgt, vector<int> &val, vector<vector<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] = max(no, yes);
+    return mem[i][c];
+}
+
+/* Рюкзак 0-1: динамическое программирование */
+int knapsackDP(vector<int> &wgt, vector<int> &val, int cap) {
+    int n = wgt.size();
+    // Инициализация таблицы dp
+    vector<vector<int>> dp(n + 1, vector<int>(cap + 1, 0));
+    // Переход состояний
+    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] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);
+            }
+        }
+    }
+    return dp[n][cap];
+}
+
+/* Рюкзак 0-1: динамическое программирование с оптимизацией памяти */
+int knapsackDPComp(vector<int> &wgt, vector<int> &val, int cap) {
+    int n = wgt.size();
+    // Инициализация таблицы dp
+    vector<int> dp(cap + 1, 0);
+    // Переход состояний
+    for (int i = 1; i <= n; i++) {
+        // Обход в обратном порядке
+        for (int c = cap; c >= 1; c--) {
+            if (wgt[i - 1] <= c) {
+                // Большее из двух решений: не брать или взять предмет i
+                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);
+            }
+        }
+    }
+    return dp[cap];
+}
+
+/* Driver Code */
+int main() {
+    vector<int> wgt = {10, 20, 30, 40, 50};
+    vector<int> val = {50, 120, 150, 210, 240};
+    int cap = 50;
+    int n = wgt.size();
+
+    // Полный перебор
+    int res = knapsackDFS(wgt, val, n, cap);
+    cout << "Максимальная стоимость предметов, не превышающая вместимость рюкзака, равна " << res << endl;
+
+    // Поиск с мемоизацией
+    vector<vector<int>> mem(n + 1, vector<int>(cap + 1, -1));
+    res = knapsackDFSMem(wgt, val, mem, n, cap);
+    cout << "Максимальная стоимость предметов, не превышающая вместимость рюкзака, равна " << res << endl;
+
+    // Динамическое программирование
+    res = knapsackDP(wgt, val, cap);
+    cout << "Максимальная стоимость предметов, не превышающая вместимость рюкзака, равна " << res << endl;
+
+    // Динамическое программирование с оптимизацией памяти
+    res = knapsackDPComp(wgt, val, cap);
+    cout << "Максимальная стоимость предметов, не превышающая вместимость рюкзака, равна " << res << endl;
+
+    return 0;
+}

ru/codes/cpp/chapter_dynamic_programming/min_cost_climbing_stairs_dp.cpp

@@ -0,0 +1,53 @@
+/**
+ * File: min_cost_climbing_stairs_dp.cpp
+ * Created Time: 2023-06-30
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Минимальная стоимость подъема по лестнице: динамическое программирование */
+int minCostClimbingStairsDP(vector<int> &cost) {
+    int n = cost.size() - 1;
+    if (n == 1 || n == 2)
+        return cost[n];
+    // Инициализация таблицы dp для хранения решений подзадач
+    vector<int> dp(n + 1);
+    // Начальное состояние: заранее задать решения наименьших подзадач
+    dp[1] = cost[1];
+    dp[2] = cost[2];
+    // Переход состояний: постепенное решение больших подзадач через меньшие
+    for (int i = 3; i <= n; i++) {
+        dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i];
+    }
+    return dp[n];
+}
+
+/* Минимальная стоимость подъема по лестнице: динамическое программирование с оптимизацией памяти */
+int minCostClimbingStairsDPComp(vector<int> &cost) {
+    int n = cost.size() - 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 = min(a, tmp) + cost[i];
+        a = tmp;
+    }
+    return b;
+}
+
+/* Driver Code */
+int main() {
+    vector<int> cost = {0, 1, 10, 1, 1, 1, 10, 1, 1, 10, 1};
+    cout << "Список стоимостей ступеней = ";
+    printVector(cost);
+
+    int res = minCostClimbingStairsDP(cost);
+    cout << "Минимальная стоимость подъема по лестнице = " << res << endl;
+
+    res = minCostClimbingStairsDPComp(cost);
+    cout << "Минимальная стоимость подъема по лестнице = " << res << endl;
+
+    return 0;
+}

ru/codes/cpp/chapter_dynamic_programming/min_path_sum.cpp

@@ -0,0 +1,116 @@
+/**
+ * File: min_path_sum.cpp
+ * Created Time: 2023-07-10
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Минимальная сумма пути: полный перебор */
+int minPathSumDFS(vector<vector<int>> &grid, int i, int j) {
+    // Если это верхняя левая ячейка, завершить поиск
+    if (i == 0 && j == 0) {
+        return grid[0][0];
+    }
+    // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞
+    if (i < 0 || j < 0) {
+        return INT_MAX;
+    }
+    // Вычислить минимальную стоимость пути из левого верхнего угла до (i-1, j) и (i, j-1)
+    int up = minPathSumDFS(grid, i - 1, j);
+    int left = minPathSumDFS(grid, i, j - 1);
+    // Вернуть минимальную стоимость пути из левого верхнего угла до (i, j)
+    return min(left, up) != INT_MAX ? min(left, up) + grid[i][j] : INT_MAX;
+}
+
+/* Минимальная сумма пути: поиск с мемоизацией */
+int minPathSumDFSMem(vector<vector<int>> &grid, vector<vector<int>> &mem, int i, int j) {
+    // Если это верхняя левая ячейка, завершить поиск
+    if (i == 0 && j == 0) {
+        return grid[0][0];
+    }
+    // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞
+    if (i < 0 || j < 0) {
+        return INT_MAX;
+    }
+    // Если запись уже есть, вернуть сразу
+    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] = min(left, up) != INT_MAX ? min(left, up) + grid[i][j] : INT_MAX;
+    return mem[i][j];
+}
+
+/* Минимальная сумма пути: динамическое программирование */
+int minPathSumDP(vector<vector<int>> &grid) {
+    int n = grid.size(), m = grid[0].size();
+    // Инициализация таблицы dp
+    vector<vector<int>> dp(n, vector<int>(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] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];
+        }
+    }
+    return dp[n - 1][m - 1];
+}
+
+/* Минимальная сумма пути: динамическое программирование с оптимизацией памяти */
+int minPathSumDPComp(vector<vector<int>> &grid) {
+    int n = grid.size(), m = grid[0].size();
+    // Инициализация таблицы dp
+    vector<int> dp(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] = min(dp[j - 1], dp[j]) + grid[i][j];
+        }
+    }
+    return dp[m - 1];
+}
+
+/* Driver Code */
+int main() {
+    vector<vector<int>> grid = {{1, 3, 1, 5}, {2, 2, 4, 2}, {5, 3, 2, 1}, {4, 3, 5, 2}};
+    int n = grid.size(), m = grid[0].size();
+
+    // Полный перебор
+    int res = minPathSumDFS(grid, n - 1, m - 1);
+    cout << "Минимальная сумма пути из левого верхнего в правый нижний угол = " << res << endl;
+
+    // Поиск с мемоизацией
+    vector<vector<int>> mem(n, vector<int>(m, -1));
+    res = minPathSumDFSMem(grid, mem, n - 1, m - 1);
+    cout << "Минимальная сумма пути из левого верхнего в правый нижний угол = " << res << endl;
+
+    // Динамическое программирование
+    res = minPathSumDP(grid);
+    cout << "Минимальная сумма пути из левого верхнего в правый нижний угол = " << res << endl;
+
+    // Динамическое программирование с оптимизацией памяти
+    res = minPathSumDPComp(grid);
+    cout << "Минимальная сумма пути из левого верхнего в правый нижний угол = " << res << endl;
+
+    return 0;
+}

ru/codes/cpp/chapter_dynamic_programming/unbounded_knapsack.cpp

@@ -0,0 +1,64 @@
+/**
+ * File: unbounded_knapsack.cpp
+ * Created Time: 2023-07-11
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Полный рюкзак: динамическое программирование */
+int unboundedKnapsackDP(vector<int> &wgt, vector<int> &val, int cap) {
+    int n = wgt.size();
+    // Инициализация таблицы dp
+    vector<vector<int>> dp(n + 1, vector<int>(cap + 1, 0));
+    // Переход состояний
+    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] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);
+            }
+        }
+    }
+    return dp[n][cap];
+}
+
+/* Полный рюкзак: динамическое программирование с оптимизацией памяти */
+int unboundedKnapsackDPComp(vector<int> &wgt, vector<int> &val, int cap) {
+    int n = wgt.size();
+    // Инициализация таблицы dp
+    vector<int> dp(cap + 1, 0);
+    // Переход состояний
+    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] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);
+            }
+        }
+    }
+    return dp[cap];
+}
+
+/* Driver code */
+int main() {
+    vector<int> wgt = {1, 2, 3};
+    vector<int> val = {5, 11, 15};
+    int cap = 4;
+
+    // Динамическое программирование
+    int res = unboundedKnapsackDP(wgt, val, cap);
+    cout << "Максимальная стоимость предметов, не превышающая вместимость рюкзака, равна " << res << endl;
+
+    // Динамическое программирование с оптимизацией памяти
+    res = unboundedKnapsackDPComp(wgt, val, cap);
+    cout << "Максимальная стоимость предметов, не превышающая вместимость рюкзака, равна " << res << endl;
+
+    return 0;
+}

ru/codes/cpp/chapter_graph/CMakeLists.txt

@@ -0,0 +1,5 @@
+add_executable(graph_bfs graph_bfs.cpp)
+add_executable(graph_dfs graph_dfs.cpp)
+# add_executable(graph_adjacency_list graph_adjacency_list.cpp)
+add_executable(graph_adjacency_list_test graph_adjacency_list_test.cpp)
+add_executable(graph_adjacency_matrix graph_adjacency_matrix.cpp)

ru/codes/cpp/chapter_graph/graph_adjacency_list.cpp

@@ -0,0 +1,90 @@
+/**
+ * File: graph_adjacency_list.cpp
+ * Created Time: 2023-02-09
+ * Author: what-is-me (whatisme@outlook.jp), krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Класс неориентированного графа на основе списка смежности */
+class GraphAdjList {
+  public:
+    // Список смежности, где key — вершина, а value — все смежные ей вершины
+    unordered_map<Vertex *, vector<Vertex *>> adjList;
+
+    /* Удалить указанный узел из vector */
+    void remove(vector<Vertex *> &vec, Vertex *vet) {
+        for (int i = 0; i < vec.size(); i++) {
+            if (vec[i] == vet) {
+                vec.erase(vec.begin() + i);
+                break;
+            }
+        }
+    }
+
+    /* Конструктор */
+    GraphAdjList(const vector<vector<Vertex *>> &edges) {
+        // Добавить все вершины и ребра
+        for (const vector<Vertex *> &edge : edges) {
+            addVertex(edge[0]);
+            addVertex(edge[1]);
+            addEdge(edge[0], edge[1]);
+        }
+    }
+
+    /* Получить число вершин */
+    int size() {
+        return adjList.size();
+    }
+
+    /* Добавление ребра */
+    void addEdge(Vertex *vet1, Vertex *vet2) {
+        if (!adjList.count(vet1) || !adjList.count(vet2) || vet1 == vet2)
+            throw invalid_argument("вершина не существует");
+        // Добавить ребро vet1 - vet2
+        adjList[vet1].push_back(vet2);
+        adjList[vet2].push_back(vet1);
+    }
+
+    /* Удаление ребра */
+    void removeEdge(Vertex *vet1, Vertex *vet2) {
+        if (!adjList.count(vet1) || !adjList.count(vet2) || vet1 == vet2)
+            throw invalid_argument("вершина не существует");
+        // Удалить ребро vet1 - vet2
+        remove(adjList[vet1], vet2);
+        remove(adjList[vet2], vet1);
+    }
+
+    /* Добавление вершины */
+    void addVertex(Vertex *vet) {
+        if (adjList.count(vet))
+            return;
+        // Добавить новый список в список смежности
+        adjList[vet] = vector<Vertex *>();
+    }
+
+    /* Удаление вершины */
+    void removeVertex(Vertex *vet) {
+        if (!adjList.count(vet))
+            throw invalid_argument("вершина не существует");
+        // Удалить из списка смежности список, соответствующий вершине vet
+        adjList.erase(vet);
+        // Обойти списки других вершин и удалить все ребра, содержащие vet
+        for (auto &adj : adjList) {
+            remove(adj.second, vet);
+        }
+    }
+
+    /* Вывести список смежности */
+    void print() {
+        cout << "Список смежности =" << endl;
+        for (auto &adj : adjList) {
+            const auto &key = adj.first;
+            const auto &vec = adj.second;
+            cout << key->val << ": ";
+            printVector(vetsToVals(vec));
+        }
+    }
+};
+
+// Тестовые примеры см. в graph_adjacency_list_test.cpp

ru/codes/cpp/chapter_graph/graph_adjacency_list_test.cpp

@@ -0,0 +1,49 @@
+/**
+ * File: graph_adjacency_list_test.cpp
+ * Created Time: 2023-02-09
+ * Author: what-is-me (whatisme@outlook.jp), krahets (krahets@163.com)
+ */
+
+#include "./graph_adjacency_list.cpp"
+
+/* Driver Code */
+int main() {
+    /* Инициализация неориентированного графа */
+    vector<Vertex *> v = valsToVets(vector<int>{1, 3, 2, 5, 4});
+    vector<vector<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(edges);
+    cout << "\nПосле инициализации граф имеет вид" << endl;
+    graph.print();
+
+    /* Добавление ребра */
+    // Вершины 1 и 2 соответствуют v[0] и v[2]
+    graph.addEdge(v[0], v[2]);
+    cout << "\nПосле добавления ребра 1-2 граф имеет вид" << endl;
+    graph.print();
+
+    /* Удаление ребра */
+    // Вершины 1 и 3 соответствуют v[0] и v[1]
+    graph.removeEdge(v[0], v[1]);
+    cout << "\nПосле удаления ребра 1-3 граф имеет вид" << endl;
+    graph.print();
+
+    /* Добавление вершины */
+    Vertex *v5 = new Vertex(6);
+    graph.addVertex(v5);
+    cout << "\nПосле добавления вершины 6 граф имеет вид" << endl;
+    graph.print();
+
+    /* Удаление вершины */
+    // Вершина 3 соответствует v[1]
+    graph.removeVertex(v[1]);
+    cout << "\nПосле удаления вершины 3 граф имеет вид" << endl;
+    graph.print();
+
+    // Освободить память
+    for (Vertex *vet : v) {
+        delete vet;
+    }
+
+    return 0;
+}

ru/codes/cpp/chapter_graph/graph_adjacency_matrix.cpp

@@ -0,0 +1,127 @@
+/**
+ * File: graph_adjacency_matrix.cpp
+ * Created Time: 2023-02-09
+ * Author: what-is-me (whatisme@outlook.jp)
+ */
+
+#include "../utils/common.hpp"
+
+/* Класс неориентированного графа на основе матрицы смежности */
+class GraphAdjMat {
+    vector<int> vertices;       // Список вершин: элементы представляют «значения вершин», а индексы — «индексы вершин»
+    vector<vector<int>> adjMat; // Матрица смежности, где индексы строк и столбцов соответствуют «индексам вершин»
+
+  public:
+    /* Конструктор */
+    GraphAdjMat(const vector<int> &vertices, const vector<vector<int>> &edges) {
+        // Добавление вершины
+        for (int val : vertices) {
+            addVertex(val);
+        }
+        // Добавить ребра
+        // Обратите внимание: элементы edges представляют собой индексы вершин, то есть соответствуют индексам элементов vertices
+        for (const vector<int> &edge : edges) {
+            addEdge(edge[0], edge[1]);
+        }
+    }
+
+    /* Получить число вершин */
+    int size() const {
+        return vertices.size();
+    }
+
+    /* Добавление вершины */
+    void addVertex(int val) {
+        int n = size();
+        // Добавить значение новой вершины в список вершин
+        vertices.push_back(val);
+        // Добавить строку в матрицу смежности
+        adjMat.emplace_back(vector<int>(n, 0));
+        // Добавить столбец в матрицу смежности
+        for (vector<int> &row : adjMat) {
+            row.push_back(0);
+        }
+    }
+
+    /* Удаление вершины */
+    void removeVertex(int index) {
+        if (index >= size()) {
+            throw out_of_range("вершина не существует");
+        }
+        // Удалить вершину с индексом index из списка вершин
+        vertices.erase(vertices.begin() + index);
+        // Удалить строку с индексом index из матрицы смежности
+        adjMat.erase(adjMat.begin() + index);
+        // Удалить столбец с индексом index из матрицы смежности
+        for (vector<int> &row : adjMat) {
+            row.erase(row.begin() + index);
+        }
+    }
+
+    /* Добавление ребра */
+    // Параметры i и j соответствуют индексам элементов vertices
+    void addEdge(int i, int j) {
+        // Обработка выхода индекса за границы и случая равенства
+        if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {
+            throw out_of_range("вершина не существует");
+        }
+        // В неориентированном графе матрица смежности симметрична относительно главной диагонали, то есть выполняется (i, j) == (j, i)
+        adjMat[i][j] = 1;
+        adjMat[j][i] = 1;
+    }
+
+    /* Удаление ребра */
+    // Параметры i и j соответствуют индексам элементов vertices
+    void removeEdge(int i, int j) {
+        // Обработка выхода индекса за границы и случая равенства
+        if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {
+            throw out_of_range("вершина не существует");
+        }
+        adjMat[i][j] = 0;
+        adjMat[j][i] = 0;
+    }
+
+    /* Вывести матрицу смежности */
+    void print() {
+        cout << "Список вершин = ";
+        printVector(vertices);
+        cout << "Матрица смежности =" << endl;
+        printVectorMatrix(adjMat);
+    }
+};
+
+/* Driver Code */
+int main() {
+    /* Инициализация неориентированного графа */
+    // Обратите внимание: элементы edges представляют индексы вершин, то есть соответствуют индексам элементов vertices
+    vector<int> vertices = {1, 3, 2, 5, 4};
+    vector<vector<int>> edges = {{0, 1}, {0, 3}, {1, 2}, {2, 3}, {2, 4}, {3, 4}};
+    GraphAdjMat graph(vertices, edges);
+    cout << "\nПосле инициализации граф имеет вид" << endl;
+    graph.print();
+
+    /* Добавление ребра */
+    // Индексы вершин 1 и 2 равны 0 и 2 соответственно
+    graph.addEdge(0, 2);
+    cout << "\nПосле добавления ребра 1-2 граф имеет вид" << endl;
+    graph.print();
+
+    /* Удаление ребра */
+    // Индексы вершин 1 и 3 равны 0 и 1 соответственно
+    graph.removeEdge(0, 1);
+    cout << "\nПосле удаления ребра 1-3 граф имеет вид" << endl;
+    graph.print();
+
+    /* Добавление вершины */
+    graph.addVertex(6);
+    cout << "\nПосле добавления вершины 6 граф имеет вид" << endl;
+    graph.print();
+
+    /* Удаление вершины */
+    // Индекс вершины 3 равен 1
+    graph.removeVertex(1);
+    cout << "\nПосле удаления вершины 3 граф имеет вид" << endl;
+    graph.print();
+
+    return 0;
+}

ru/codes/cpp/chapter_graph/graph_bfs.cpp

@@ -0,0 +1,59 @@
+/**
+ * File: graph_bfs.cpp
+ * Created Time: 2023-03-02
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+#include "./graph_adjacency_list.cpp"
+
+/* Обход в ширину */
+// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины
+vector<Vertex *> graphBFS(GraphAdjList &graph, Vertex *startVet) {
+    // Последовательность обхода вершин
+    vector<Vertex *> res;
+    // Хеш-множество для хранения уже посещенных вершин
+    unordered_set<Vertex *> visited = {startVet};
+    // Очередь используется для реализации BFS
+    queue<Vertex *> que;
+    que.push(startVet);
+    // Начиная с вершины vet, продолжать цикл, пока не будут посещены все вершины
+    while (!que.empty()) {
+        Vertex *vet = que.front();
+        que.pop();          // Извлечь головную вершину из очереди
+        res.push_back(vet); // Отметить посещенную вершину
+        // Обойти все смежные вершины данной вершины
+        for (auto adjVet : graph.adjList[vet]) {
+            if (visited.count(adjVet))
+                continue;            // Пропустить уже посещенную вершину
+            que.push(adjVet);        // Помещать в очередь только непосещенные вершины
+            visited.emplace(adjVet); // Отметить эту вершину как посещенную
+        }
+    }
+    // Вернуть последовательность обхода вершин
+    return res;
+}
+
+/* Driver Code */
+int main() {
+    /* Инициализация неориентированного графа */
+    vector<Vertex *> v = valsToVets({0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
+    vector<vector<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(edges);
+    cout << "\nПосле инициализации граф имеет вид\n";
+    graph.print();
+
+    /* Обход в ширину */
+    vector<Vertex *> res = graphBFS(graph, v[0]);
+    cout << "\nПоследовательность вершин при обходе в ширину (BFS)" << endl;
+    printVector(vetsToVals(res));
+
+    // Освободить память
+    for (Vertex *vet : v) {
+        delete vet;
+    }
+
+    return 0;
+}

ru/codes/cpp/chapter_graph/graph_dfs.cpp

@@ -0,0 +1,55 @@
+/**
+ * File: graph_dfs.cpp
+ * Created Time: 2023-03-02
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+#include "./graph_adjacency_list.cpp"
+
+/* Вспомогательная функция обхода в глубину */
+void dfs(GraphAdjList &graph, unordered_set<Vertex *> &visited, vector<Vertex *> &res, Vertex *vet) {
+    res.push_back(vet);   // Отметить посещенную вершину
+    visited.emplace(vet); // Отметить эту вершину как посещенную
+    // Обойти все смежные вершины данной вершины
+    for (Vertex *adjVet : graph.adjList[vet]) {
+        if (visited.count(adjVet))
+            continue; // Пропустить уже посещенную вершину
+        // Рекурсивно обходить смежные вершины
+        dfs(graph, visited, res, adjVet);
+    }
+}
+
+/* Обход в глубину */
+// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины
+vector<Vertex *> graphDFS(GraphAdjList &graph, Vertex *startVet) {
+    // Последовательность обхода вершин
+    vector<Vertex *> res;
+    // Хеш-множество для хранения уже посещенных вершин
+    unordered_set<Vertex *> visited;
+    dfs(graph, visited, res, startVet);
+    return res;
+}
+
+/* Driver Code */
+int main() {
+    /* Инициализация неориентированного графа */
+    vector<Vertex *> v = valsToVets(vector<int>{0, 1, 2, 3, 4, 5, 6});
+    vector<vector<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(edges);
+    cout << "\nПосле инициализации граф имеет вид" << endl;
+    graph.print();
+
+    /* Обход в глубину */
+    vector<Vertex *> res = graphDFS(graph, v[0]);
+    cout << "\nПоследовательность вершин при обходе в глубину (DFS)" << endl;
+    printVector(vetsToVals(res));
+
+    // Освободить память
+    for (Vertex *vet : v) {
+        delete vet;
+    }
+
+    return 0;
+}

ru/codes/cpp/chapter_greedy/CMakeLists.txt

@@ -0,0 +1,3 @@
+add_executable(coin_change_greedy coin_change_greedy.cpp)
+add_executable(fractional_knapsack fractional_knapsack.cpp)
+add_executable(max_capacity max_capacity.cpp)

ru/codes/cpp/chapter_greedy/coin_change_greedy.cpp

@@ -0,0 +1,60 @@
+/**
+ * File: coin_change_greedy.cpp
+ * Created Time: 2023-07-20
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Размен монет: жадный алгоритм */
+int coinChangeGreedy(vector<int> &coins, int amt) {
+    // Предположить, что список coins упорядочен
+    int i = coins.size() - 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;
+}
+
+/* Driver Code */
+int main() {
+    // Жадный подход: гарантирует нахождение глобально оптимального решения
+    vector<int> coins = {1, 5, 10, 20, 50, 100};
+    int amt = 186;
+    int res = coinChangeGreedy(coins, amt);
+    cout << "\ncoins = ";
+    printVector(coins);
+    cout << "amt = " << amt << endl;
+    cout << "Минимальное количество монет для набора суммы " << amt << " = " << res << endl;
+
+    // Жадный подход: не гарантирует нахождение глобально оптимального решения
+    coins = {1, 20, 50};
+    amt = 60;
+    res = coinChangeGreedy(coins, amt);
+    cout << "\ncoins = ";
+    printVector(coins);
+    cout << "amt = " << amt << endl;
+    cout << "Минимальное количество монет для набора суммы " << amt << " = " << res << endl;
+    cout << "На самом деле минимальное количество равно 3, а именно 20 + 20 + 20" << endl;
+
+    // Жадный подход: не гарантирует нахождение глобально оптимального решения
+    coins = {1, 49, 50};
+    amt = 98;
+    res = coinChangeGreedy(coins, amt);
+    cout << "\ncoins = ";
+    printVector(coins);
+    cout << "amt = " << amt << endl;
+    cout << "Минимальное количество монет для набора суммы " << amt << " = " << res << endl;
+    cout << "На самом деле минимальное количество равно 2, а именно 49 + 49" << endl;
+
+    return 0;
+}

ru/codes/cpp/chapter_greedy/fractional_knapsack.cpp

@@ -0,0 +1,56 @@
+/**
+ * File: fractional_knapsack.cpp
+ * Created Time: 2023-07-20
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Предмет */
+class Item {
+  public:
+    int w; // Вес предмета
+    int v; // Стоимость предмета
+
+    Item(int w, int v) : w(w), v(v) {
+    }
+};
+
+/* Дробный рюкзак: жадный алгоритм */
+double fractionalKnapsack(vector<int> &wgt, vector<int> &val, int cap) {
+    // Создать список предметов с двумя свойствами: вес и стоимость
+    vector<Item> items;
+    for (int i = 0; i < wgt.size(); i++) {
+        items.push_back(Item(wgt[i], val[i]));
+    }
+    // Отсортировать по удельной стоимости item.v / item.w в порядке убывания
+    sort(items.begin(), items.end(), [](Item &a, Item &b) { return (double)a.v / a.w > (double)b.v / b.w; });
+    // Циклический жадный выбор
+    double res = 0;
+    for (auto &item : items) {
+        if (item.w <= cap) {
+            // Если оставшейся вместимости достаточно, положить в рюкзак текущий предмет целиком
+            res += item.v;
+            cap -= item.w;
+        } else {
+            // Если оставшейся вместимости недостаточно, положить в рюкзак часть текущего предмета
+            res += (double)item.v / item.w * cap;
+            // Свободной вместимости больше не осталось, поэтому выйти из цикла
+            break;
+        }
+    }
+    return res;
+}
+
+/* Driver Code */
+int main() {
+    vector<int> wgt = {10, 20, 30, 40, 50};
+    vector<int> val = {50, 120, 150, 210, 240};
+    int cap = 50;
+
+    // Жадный алгоритм
+    double res = fractionalKnapsack(wgt, val, cap);
+    cout << "Максимальная стоимость предметов, не превышающая вместимость рюкзака, равна " << res << endl;
+
+    return 0;
+}

ru/codes/cpp/chapter_greedy/max_capacity.cpp

@@ -0,0 +1,39 @@
+/**
+ * File: max_capacity.cpp
+ * Created Time: 2023-07-21
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Максимальная вместимость: жадный алгоритм */
+int maxCapacity(vector<int> &ht) {
+    // Инициализировать i и j так, чтобы они располагались по двум концам массива
+    int i = 0, j = ht.size() - 1;
+    // Начальная максимальная вместимость равна 0
+    int res = 0;
+    // Выполнять жадный выбор в цикле, пока две доски не встретятся
+    while (i < j) {
+        // Обновить максимальную вместимость
+        int cap = min(ht[i], ht[j]) * (j - i);
+        res = max(res, cap);
+        // Сдвигать внутрь более короткую сторону
+        if (ht[i] < ht[j]) {
+            i++;
+        } else {
+            j--;
+        }
+    }
+    return res;
+}
+
+/* Driver Code */
+int main() {
+    vector<int> ht = {3, 8, 5, 2, 7, 7, 3, 4};
+
+    // Жадный алгоритм
+    int res = maxCapacity(ht);
+    cout << "Максимальная вместимость = " << res << endl;
+
+    return 0;
+}

ru/codes/cpp/chapter_greedy/max_product_cutting.cpp

@@ -0,0 +1,39 @@
+/**
+ * File: max_product_cutting.cpp
+ * Created Time: 2023-07-21
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Максимальное произведение разрезания: жадный алгоритм */
+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)pow(3, a - 1) * 2 * 2;
+    }
+    if (b == 2) {
+        // Если остаток равен 2, ничего не делать
+        return (int)pow(3, a) * 2;
+    }
+    // Если остаток равен 0, ничего не делать
+    return (int)pow(3, a);
+}
+
+/* Driver Code */
+int main() {
+    int n = 58;
+
+    // Жадный алгоритм
+    int res = maxProductCutting(n);
+    cout << "Максимальное произведение после разрезания = " << res << endl;
+
+    return 0;
+}

ru/codes/cpp/chapter_hashing/CMakeLists.txt

@@ -0,0 +1,6 @@
+add_executable(hash_map hash_map.cpp)
+add_executable(array_hash_map_test array_hash_map_test.cpp)
+add_executable(hash_map_chaining hash_map_chaining.cpp)
+add_executable(hash_map_open_addressing hash_map_open_addressing.cpp)
+add_executable(simple_hash simple_hash.cpp)
+add_executable(built_in_hash built_in_hash.cpp)

ru/codes/cpp/chapter_hashing/array_hash_map.cpp

@@ -0,0 +1,110 @@
+/**
+ * File: array_hash_map.cpp
+ * Created Time: 2022-12-14
+ * Author: msk397 (machangxinq@gmail.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Пара ключ-значение */
+struct Pair {
+  public:
+    int key;
+    string val;
+    Pair(int key, string val) {
+        this->key = key;
+        this->val = val;
+    }
+};
+
+/* Хеш-таблица на основе массива */
+class ArrayHashMap {
+  private:
+    vector<Pair *> buckets;
+
+  public:
+    ArrayHashMap() {
+        // Инициализировать массив, содержащий 100 корзин
+        buckets = vector<Pair *>(100);
+    }
+
+    ~ArrayHashMap() {
+        // Освободить память
+        for (const auto &bucket : buckets) {
+            delete bucket;
+        }
+        buckets.clear();
+    }
+
+    /* Хеш-функция */
+    int hashFunc(int key) {
+        int index = key % 100;
+        return index;
+    }
+
+    /* Операция поиска */
+    string get(int key) {
+        int index = hashFunc(key);
+        Pair *pair = buckets[index];
+        if (pair == nullptr)
+            return "";
+        return pair->val;
+    }
+
+    /* Операция добавления */
+    void put(int key, string val) {
+        Pair *pair = new Pair(key, val);
+        int index = hashFunc(key);
+        buckets[index] = pair;
+    }
+
+    /* Операция удаления */
+    void remove(int key) {
+        int index = hashFunc(key);
+        // Освободить память и присвоить nullptr
+        delete buckets[index];
+        buckets[index] = nullptr;
+    }
+
+    /* Получить все пары ключ-значение */
+    vector<Pair *> pairSet() {
+        vector<Pair *> pairSet;
+        for (Pair *pair : buckets) {
+            if (pair != nullptr) {
+                pairSet.push_back(pair);
+            }
+        }
+        return pairSet;
+    }
+
+    /* Получить все ключи */
+    vector<int> keySet() {
+        vector<int> keySet;
+        for (Pair *pair : buckets) {
+            if (pair != nullptr) {
+                keySet.push_back(pair->key);
+            }
+        }
+        return keySet;
+    }
+
+    /* Получить все значения */
+    vector<string> valueSet() {
+        vector<string> valueSet;
+        for (Pair *pair : buckets) {
+            if (pair != nullptr) {
+                valueSet.push_back(pair->val);
+            }
+        }
+        return valueSet;
+    }
+
+    /* Вывести хеш-таблицу */
+    void print() {
+        for (Pair *kv : pairSet()) {
+            cout << kv->key << " -> " << kv->val << endl;
+        }
+    }
+};
+
+// Тестовые примеры см. в array_hash_map_test.cpp

ru/codes/cpp/chapter_hashing/array_hash_map_test.cpp

@@ -0,0 +1,52 @@
+/**
+ * File: array_hash_map_test.cpp
+ * Created Time: 2022-12-14
+ * Author: msk397 (machangxinq@gmail.com)
+ */
+
+#include "./array_hash_map.cpp"
+
+/* Driver Code */
+int main() {
+    /* Инициализация хеш-таблицы */
+    ArrayHashMap map = ArrayHashMap();
+
+    /* Операция добавления */
+    // Добавить пару (key, value) в хеш-таблицу
+    map.put(12836, "Сяо Ха");
+    map.put(15937, "Сяо Ло");
+    map.put(16750, "Сяо Суань");
+    map.put(13276, "Сяо Фа");
+    map.put(10583, "Сяо Я");
+    cout << "\nПосле добавления хеш-таблица имеет вид\nКлюч -> Значение" << endl;
+    map.print();
+
+    /* Операция поиска */
+    // Ввести в хеш-таблицу ключ key и получить значение value
+    string name = map.get(15937);
+    cout << "\nДля студенческого номера 15937 найдено имя " << name << endl;
+
+    /* Операция удаления */
+    // Удалить пару (key, value) из хеш-таблицы
+    map.remove(10583);
+    cout << "\nПосле удаления 10583 хеш-таблица имеет вид\nКлюч -> Значение" << endl;
+    map.print();
+
+    /* Обход хеш-таблицы */
+    cout << "\nОтдельный обход пар ключ-значение" << endl;
+    for (auto kv : map.pairSet()) {
+        cout << kv->key << " -> " << kv->val << endl;
+    }
+
+    cout << "\nОтдельный обход ключей" << endl;
+    for (auto key : map.keySet()) {
+        cout << key << endl;
+    }
+
+    cout << "\nОтдельный обход значений" << endl;
+    for (auto val : map.valueSet()) {
+        cout << val << endl;
+    }
+
+    return 0;
+}

ru/codes/cpp/chapter_hashing/built_in_hash.cpp

@@ -0,0 +1,29 @@
+/**
+ * File: built_in_hash.cpp
+ * Created Time: 2023-06-21
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Driver Code */
+int main() {
+    int num = 3;
+    size_t hashNum = hash<int>()(num);
+    cout << "Хеш-значение целого числа " << num << " = " << hashNum << "\n";
+
+    bool bol = true;
+    size_t hashBol = hash<bool>()(bol);
+    cout << "Хеш-значение булева значения " << bol << " = " << hashBol << "\n";
+
+    double dec = 3.14159;
+    size_t hashDec = hash<double>()(dec);
+    cout << "Хеш-значение десятичного числа " << dec << " = " << hashDec << "\n";
+
+    string str = "Hello Algo";
+    size_t hashStr = hash<string>()(str);
+    cout << "Хеш-значение строки " << str << " = " << hashStr << "\n";
+
+    // В C++ встроенный std::hash() предоставляет вычисление хеша только для базовых типов данных
+    // Вычисление хеша для массивов и объектов нужно реализовывать самостоятельно
+}

ru/codes/cpp/chapter_hashing/hash_map.cpp

@@ -0,0 +1,46 @@
+/**
+ * File: hash_map.cpp
+ * Created Time: 2022-12-14
+ * Author: msk397 (machangxinq@gmail.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Driver Code */
+int main() {
+    /* Инициализация хеш-таблицы */
+    unordered_map<int, string> map;
+
+    /* Операция добавления */
+    // Добавить пару (key, value) в хеш-таблицу
+    map[12836] = "Сяо Ха";
+    map[15937] = "Сяо Ло";
+    map[16750] = "Сяо Суань";
+    map[13276] = "Сяо Фа";
+    map[10583] = "Сяо Я";
+    cout << "\nПосле добавления хеш-таблица имеет вид\nКлюч -> Значение" << endl;
+    printHashMap(map);
+
+    /* Операция поиска */
+    // Ввести в хеш-таблицу ключ key и получить значение value
+    string name = map[15937];
+    cout << "\nДля студенческого номера 15937 найдено имя " << name << endl;
+
+    /* Операция удаления */
+    // Удалить пару (key, value) из хеш-таблицы
+    map.erase(10583);
+    cout << "\nПосле удаления 10583 хеш-таблица имеет вид\nКлюч -> Значение" << endl;
+    printHashMap(map);
+
+    /* Обход хеш-таблицы */
+    cout << "\nОтдельный обход пар ключ-значение" << endl;
+    for (auto kv : map) {
+        cout << kv.first << " -> " << kv.second << endl;
+    }
+    cout << "\nОбход пар Key->Value с помощью итератора" << endl;
+    for (auto iter = map.begin(); iter != map.end(); iter++) {
+        cout << iter->first << "->" << iter->second << endl;
+    }
+
+    return 0;
+}

ru/codes/cpp/chapter_hashing/hash_map_chaining.cpp

@@ -0,0 +1,150 @@
+/**
+ * File: hash_map_chaining.cpp
+ * Created Time: 2023-06-13
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "./array_hash_map.cpp"
+
+/* Хеш-таблица с цепочками */
+class HashMapChaining {
+  private:
+    int size;                       // Число пар ключ-значение
+    int capacity;                   // Вместимость хеш-таблицы
+    double loadThres;               // Порог коэффициента загрузки для запуска расширения
+    int extendRatio;                // Коэффициент расширения
+    vector<vector<Pair *>> buckets; // Массив корзин
+
+  public:
+    /* Конструктор */
+    HashMapChaining() : size(0), capacity(4), loadThres(2.0 / 3.0), extendRatio(2) {
+        buckets.resize(capacity);
+    }
+
+    /* Метод-деструктор */
+    ~HashMapChaining() {
+        for (auto &bucket : buckets) {
+            for (Pair *pair : bucket) {
+                // Освободить память
+                delete pair;
+            }
+        }
+    }
+
+    /* Хеш-функция */
+    int hashFunc(int key) {
+        return key % capacity;
+    }
+
+    /* Коэффициент загрузки */
+    double loadFactor() {
+        return (double)size / (double)capacity;
+    }
+
+    /* Операция поиска */
+    string get(int key) {
+        int index = hashFunc(key);
+        // Обойти корзину; если найден key, вернуть соответствующее val
+        for (Pair *pair : buckets[index]) {
+            if (pair->key == key) {
+                return pair->val;
+            }
+        }
+        // Если key не найден, вернуть пустую строку
+        return "";
+    }
+
+    /* Операция добавления */
+    void put(int key, string val) {
+        // Когда коэффициент загрузки превышает порог, выполнить расширение
+        if (loadFactor() > loadThres) {
+            extend();
+        }
+        int index = hashFunc(key);
+        // Обойти корзину; если встретился указанный key, обновить соответствующее val и вернуть
+        for (Pair *pair : buckets[index]) {
+            if (pair->key == key) {
+                pair->val = val;
+                return;
+            }
+        }
+        // Если такого key нет, добавить пару ключ-значение в конец
+        buckets[index].push_back(new Pair(key, val));
+        size++;
+    }
+
+    /* Операция удаления */
+    void remove(int key) {
+        int index = hashFunc(key);
+        auto &bucket = buckets[index];
+        // Обойти корзину и удалить из нее пару ключ-значение
+        for (int i = 0; i < bucket.size(); i++) {
+            if (bucket[i]->key == key) {
+                Pair *tmp = bucket[i];
+                bucket.erase(bucket.begin() + i); // Удалить из него пару ключ-значение
+                delete tmp;                       // Освободить память
+                size--;
+                return;
+            }
+        }
+    }
+
+    /* Расширить хеш-таблицу */
+    void extend() {
+        // Временно сохранить исходную хеш-таблицу
+        vector<vector<Pair *>> bucketsTmp = buckets;
+        // Инициализация новой хеш-таблицы после расширения
+        capacity *= extendRatio;
+        buckets.clear();
+        buckets.resize(capacity);
+        size = 0;
+        // Перенести пары ключ-значение из исходной хеш-таблицы в новую
+        for (auto &bucket : bucketsTmp) {
+            for (Pair *pair : bucket) {
+                put(pair->key, pair->val);
+                // Освободить память
+                delete pair;
+            }
+        }
+    }
+
+    /* Вывести хеш-таблицу */
+    void print() {
+        for (auto &bucket : buckets) {
+            cout << "[";
+            for (Pair *pair : bucket) {
+                cout << pair->key << " -> " << pair->val << ", ";
+            }
+            cout << "]\n";
+        }
+    }
+};
+
+/* Driver Code */
+int main() {
+    /* Инициализация хеш-таблицы */
+    HashMapChaining map = HashMapChaining();
+
+    /* Операция добавления */
+    // Добавить пару (key, value) в хеш-таблицу
+    map.put(12836, "Сяо Ха");
+    map.put(15937, "Сяо Ло");
+    map.put(16750, "Сяо Суань");
+    map.put(13276, "Сяо Фа");
+    map.put(10583, "Сяо Я");
+    cout << "\nПосле добавления хеш-таблица имеет вид\nКлюч -> Значение" << endl;
+    map.print();
+
+    /* Операция поиска */
+    // Ввести в хеш-таблицу ключ key и получить значение value
+    string name = map.get(13276);
+    cout << "\nДля студенческого номера 13276 найдено имя " << name << endl;
+
+    /* Операция удаления */
+    // Удалить пару (key, value) из хеш-таблицы
+    map.remove(12836);
+    cout << "\nПосле удаления 12836 хеш-таблица имеет вид\nКлюч -> Значение" << endl;
+    map.print();
+
+    return 0;
+}

ru/codes/cpp/chapter_hashing/hash_map_open_addressing.cpp

@@ -0,0 +1,171 @@
+/**
+ * File: hash_map_open_addressing.cpp
+ * Created Time: 2023-06-13
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "./array_hash_map.cpp"
+
+/* Хеш-таблица с открытой адресацией */
+class HashMapOpenAddressing {
+  private:
+    int size;                             // Число пар ключ-значение
+    int capacity = 4;                     // Вместимость хеш-таблицы
+    const double loadThres = 2.0 / 3.0;     // Порог коэффициента загрузки для запуска расширения
+    const int extendRatio = 2;            // Коэффициент расширения
+    vector<Pair *> buckets;               // Массив корзин
+    Pair *TOMBSTONE = new Pair(-1, "-1"); // Удалить метку
+
+  public:
+    /* Конструктор */
+    HashMapOpenAddressing() : size(0), buckets(capacity, nullptr) {
+    }
+
+    /* Метод-деструктор */
+    ~HashMapOpenAddressing() {
+        for (Pair *pair : buckets) {
+            if (pair != nullptr && pair != TOMBSTONE) {
+                delete pair;
+            }
+        }
+        delete TOMBSTONE;
+    }
+
+    /* Хеш-функция */
+    int hashFunc(int key) {
+        return key % capacity;
+    }
+
+    /* Коэффициент загрузки */
+    double loadFactor() {
+        return (double)size / capacity;
+    }
+
+    /* Найти индекс корзины, соответствующий key */
+    int findBucket(int key) {
+        int index = hashFunc(key);
+        int firstTombstone = -1;
+        // Выполнять линейное пробирование и завершить при встрече с пустой корзиной
+        while (buckets[index] != nullptr) {
+            // Если встретился 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;
+    }
+
+    /* Операция поиска */
+    string get(int key) {
+        // Найти индекс корзины, соответствующий key
+        int index = findBucket(key);
+        // Если пара ключ-значение найдена, вернуть соответствующее val
+        if (buckets[index] != nullptr && buckets[index] != TOMBSTONE) {
+            return buckets[index]->val;
+        }
+        // Если пары ключ-значение не существует, вернуть пустую строку
+        return "";
+    }
+
+    /* Операция добавления */
+    void put(int key, string val) {
+        // Когда коэффициент загрузки превышает порог, выполнить расширение
+        if (loadFactor() > loadThres) {
+            extend();
+        }
+        // Найти индекс корзины, соответствующий key
+        int index = findBucket(key);
+        // Если пара ключ-значение найдена, перезаписать val и вернуть
+        if (buckets[index] != nullptr && buckets[index] != TOMBSTONE) {
+            buckets[index]->val = val;
+            return;
+        }
+        // Если пары ключ-значение нет, добавить ее
+        buckets[index] = new Pair(key, val);
+        size++;
+    }
+
+    /* Операция удаления */
+    void remove(int key) {
+        // Найти индекс корзины, соответствующий key
+        int index = findBucket(key);
+        // Если пара ключ-значение найдена, заменить ее меткой удаления
+        if (buckets[index] != nullptr && buckets[index] != TOMBSTONE) {
+            delete buckets[index];
+            buckets[index] = TOMBSTONE;
+            size--;
+        }
+    }
+
+    /* Расширить хеш-таблицу */
+    void extend() {
+        // Временно сохранить исходную хеш-таблицу
+        vector<Pair *> bucketsTmp = buckets;
+        // Инициализация новой хеш-таблицы после расширения
+        capacity *= extendRatio;
+        buckets = vector<Pair *>(capacity, nullptr);
+        size = 0;
+        // Перенести пары ключ-значение из исходной хеш-таблицы в новую
+        for (Pair *pair : bucketsTmp) {
+            if (pair != nullptr && pair != TOMBSTONE) {
+                put(pair->key, pair->val);
+                delete pair;
+            }
+        }
+    }
+
+    /* Вывести хеш-таблицу */
+    void print() {
+        for (Pair *pair : buckets) {
+            if (pair == nullptr) {
+                cout << "nullptr" << endl;
+            } else if (pair == TOMBSTONE) {
+                cout << "TOMBSTONE" << endl;
+            } else {
+                cout << pair->key << " -> " << pair->val << endl;
+            }
+        }
+    }
+};
+
+/* Driver Code */
+int main() {
+    // Инициализация хеш-таблицы
+    HashMapOpenAddressing hashmap;
+
+    // Операция добавления
+    // Добавить пару (key, val) в хеш-таблицу
+    hashmap.put(12836, "Сяо Ха");
+    hashmap.put(15937, "Сяо Ло");
+    hashmap.put(16750, "Сяо Суань");
+    hashmap.put(13276, "Сяо Фа");
+    hashmap.put(10583, "Сяо Я");
+    cout << "\nПосле добавления хеш-таблица имеет вид\nКлюч -> Значение" << endl;
+    hashmap.print();
+
+    // Операция поиска
+    // Передать ключ key в хеш-таблицу и получить значение val
+    string name = hashmap.get(13276);
+    cout << "\nДля студенческого номера 13276 найдено имя " << name << endl;
+
+    // Операция удаления
+    // Удалить пару (key, val) из хеш-таблицы
+    hashmap.remove(16750);
+    cout << "\nПосле удаления 16750 хеш-таблица имеет вид\nКлюч -> Значение" << endl;
+    hashmap.print();
+
+    return 0;
+}

ru/codes/cpp/chapter_hashing/simple_hash.cpp

@@ -0,0 +1,66 @@
+/**
+ * File: simple_hash.cpp
+ * Created Time: 2023-06-21
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Аддитивное хеширование */
+int addHash(string key) {
+    long long hash = 0;
+    const int MODULUS = 1000000007;
+    for (unsigned char c : key) {
+        hash = (hash + (int)c) % MODULUS;
+    }
+    return (int)hash;
+}
+
+/* Мультипликативное хеширование */
+int mulHash(string key) {
+    long long hash = 0;
+    const int MODULUS = 1000000007;
+    for (unsigned char c : key) {
+        hash = (31 * hash + (int)c) % MODULUS;
+    }
+    return (int)hash;
+}
+
+/* XOR-хеширование */
+int xorHash(string key) {
+    int hash = 0;
+    const int MODULUS = 1000000007;
+    for (unsigned char c : key) {
+        hash ^= (int)c;
+    }
+    return hash & MODULUS;
+}
+
+/* Хеширование с циклическим сдвигом */
+int rotHash(string key) {
+    long long hash = 0;
+    const int MODULUS = 1000000007;
+    for (unsigned char c : key) {
+        hash = ((hash << 4) ^ (hash >> 28) ^ (int)c) % MODULUS;
+    }
+    return (int)hash;
+}
+
+/* Driver Code */
+int main() {
+    string key = "Hello Algo";
+
+    int hash = addHash(key);
+    cout << "Хеш суммы = " << hash << endl;
+
+    hash = mulHash(key);
+    cout << "Хеш произведения = " << hash << endl;
+
+    hash = xorHash(key);
+    cout << "XOR-хеш = " << hash << endl;
+
+    hash = rotHash(key);
+    cout << "Хеш с циклическим сдвигом = " << hash << endl;
+
+    return 0;
+}

ru/codes/cpp/chapter_heap/CMakeLists.txt

@@ -0,0 +1,3 @@
+add_executable(heap heap.cpp)
+add_executable(my_heap my_heap.cpp)
+add_executable(top_k top_k.cpp)

ru/codes/cpp/chapter_heap/heap.cpp

@@ -0,0 +1,66 @@
+/**
+ * File: heap.cpp
+ * Created Time: 2023-01-19
+ * Author: LoneRanger(836253168@qq.com)
+ */
+
+#include "../utils/common.hpp"
+
+void testPush(priority_queue<int> &heap, int val) {
+    heap.push(val); // Добавление элемента в кучу
+    cout << "\nПосле добавления элемента " << val << " в кучу" << endl;
+    printHeap(heap);
+}
+
+void testPop(priority_queue<int> &heap) {
+    int val = heap.top();
+    heap.pop();
+    cout << "\nПосле извлечения верхнего элемента " << val << " из кучи" << endl;
+    printHeap(heap);
+}
+
+/* Driver Code */
+int main() {
+    /* Инициализация кучи */
+    // Инициализировать минимальную кучу
+    // priority_queue<int, vector<int>, greater<int>> minHeap;
+    // Инициализировать максимальную кучу
+    priority_queue<int, vector<int>, less<int>> maxHeap;
+
+    cout << "\nНиже приведены тестовые примеры для max-heap" << endl;
+
+    /* Добавление элемента в кучу */
+    testPush(maxHeap, 1);
+    testPush(maxHeap, 3);
+    testPush(maxHeap, 2);
+    testPush(maxHeap, 5);
+    testPush(maxHeap, 4);
+
+    /* Получение элемента с вершины кучи */
+    int peek = maxHeap.top();
+    cout << "\nВерхний элемент кучи = " << peek << endl;
+
+    /* Извлечение элемента с вершины кучи */
+    testPop(maxHeap);
+    testPop(maxHeap);
+    testPop(maxHeap);
+    testPop(maxHeap);
+    testPop(maxHeap);
+
+    /* Получение размера кучи */
+    int size = maxHeap.size();
+    cout << "\nКоличество элементов в куче = " << size << endl;
+
+    /* Проверка, пуста ли куча */
+    bool isEmpty = maxHeap.empty();
+    cout << "\nПуста ли куча: " << isEmpty << endl;
+
+    /* Построить кучу по входному списку */
+    // Временная сложность равна O(n), а не O(nlogn)
+    vector<int> input{1, 3, 2, 5, 4};
+    priority_queue<int, vector<int>, greater<int>> minHeap(input.begin(), input.end());
+    cout << "После построения min-heap из входного списка" << endl;
+    printHeap(minHeap);
+
+    return 0;
+}

ru/codes/cpp/chapter_heap/my_heap.cpp

@@ -0,0 +1,155 @@
+/**
+ * File: my_heap.cpp
+ * Created Time: 2023-02-04
+ * Author: LoneRanger (836253168@qq.com), what-is-me (whatisme@outlook.jp)
+ */
+
+#include "../utils/common.hpp"
+
+/* Максимальная куча */
+class MaxHeap {
+  private:
+    // Использовать динамический массив, чтобы не учитывать проблему расширения
+    vector<int> maxHeap;
+
+    /* Получить индекс левого дочернего узла */
+    int left(int i) {
+        return 2 * i + 1;
+    }
+
+    /* Получить индекс правого дочернего узла */
+    int right(int i) {
+        return 2 * i + 2;
+    }
+
+    /* Получить индекс родительского узла */
+    int parent(int i) {
+        return (i - 1) / 2; // Округление вниз при делении
+    }
+
+    /* Начиная с узла i, выполнить просеивание снизу вверх */
+    void siftUp(int i) {
+        while (true) {
+            // Получение родительского узла для узла i
+            int p = parent(i);
+            // Завершить heapify, когда «корневой узел уже пройден» или «узел не требует исправления»
+            if (p < 0 || maxHeap[i] <= maxHeap[p])
+                break;
+            // Поменять два узла местами
+            swap(maxHeap[i], maxHeap[p]);
+            // Циклическое просеивание вверх
+            i = p;
+        }
+    }
+
+    /* Начиная с узла i, выполнить просеивание сверху вниз */
+    void siftDown(int i) {
+        while (true) {
+            // Определить узел с максимальным значением среди i, l и r и обозначить его как ma
+            int l = left(i), r = right(i), ma = i;
+            if (l < size() && maxHeap[l] > maxHeap[ma])
+                ma = l;
+            if (r < size() && maxHeap[r] > maxHeap[ma])
+                ma = r;
+            // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти
+            if (ma == i)
+                break;
+            swap(maxHeap[i], maxHeap[ma]);
+            // Циклическое просеивание вниз
+            i = ma;
+        }
+    }
+
+  public:
+    /* Конструктор, строящий кучу по входному списку */
+    MaxHeap(vector<int> nums) {
+        // Добавить элементы списка в кучу без изменений
+        maxHeap = nums;
+        // Выполнить heapify для всех узлов, кроме листовых
+        for (int i = parent(size() - 1); i >= 0; i--) {
+            siftDown(i);
+        }
+    }
+
+    /* Получение размера кучи */
+    int size() {
+        return maxHeap.size();
+    }
+
+    /* Проверка, пуста ли куча */
+    bool isEmpty() {
+        return size() == 0;
+    }
+
+    /* Доступ к элементу на вершине кучи */
+    int peek() {
+        return maxHeap[0];
+    }
+
+    /* Добавление элемента в кучу */
+    void push(int val) {
+        // Добавление узла
+        maxHeap.push_back(val);
+        // Просеивание снизу вверх
+        siftUp(size() - 1);
+    }
+
+    /* Извлечение элемента из кучи */
+    void pop() {
+        // Обработка пустого случая
+        if (isEmpty()) {
+            throw out_of_range("куча пуста");
+        }
+        // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)
+        swap(maxHeap[0], maxHeap[size() - 1]);
+        // Удаление узла
+        maxHeap.pop_back();
+        // Просеивание сверху вниз
+        siftDown(0);
+    }
+
+    /* Вывести кучу (двоичное дерево) */
+    void print() {
+        cout << "Массивное представление кучи:";
+        printVector(maxHeap);
+        cout << "Древовидное представление кучи:" << endl;
+        TreeNode *root = vectorToTree(maxHeap);
+        printTree(root);
+        freeMemoryTree(root);
+    }
+};
+
+/* Driver Code */
+int main() {
+    /* Инициализация максимальной кучи */
+    vector<int> vec{9, 8, 6, 6, 7, 5, 2, 1, 4, 3, 6, 2};
+    MaxHeap maxHeap(vec);
+    cout << "\nПосле построения кучи из входного списка" << endl;
+    maxHeap.print();
+
+    /* Получение элемента с вершины кучи */
+    int peek = maxHeap.peek();
+    cout << "\nВерхний элемент кучи = " << peek << endl;
+
+    /* Добавление элемента в кучу */
+    int val = 7;
+    maxHeap.push(val);
+    cout << "\nПосле добавления элемента " << val << " в кучу" << endl;
+    maxHeap.print();
+
+    /* Извлечение элемента с вершины кучи */
+    peek = maxHeap.peek();
+    maxHeap.pop();
+    cout << "\nПосле извлечения верхнего элемента " << peek << " из кучи" << endl;
+    maxHeap.print();
+
+    /* Получение размера кучи */
+    int size = maxHeap.size();
+    cout << "\nКоличество элементов в куче = " << size << endl;
+
+    /* Проверка, пуста ли куча */
+    bool isEmpty = maxHeap.isEmpty();
+    cout << "\nПуста ли куча: " << isEmpty << endl;
+
+    return 0;
+}

ru/codes/cpp/chapter_heap/top_k.cpp

@@ -0,0 +1,38 @@
+/**
+ * File: top_k.cpp
+ * Created Time: 2023-06-12
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Найти k наибольших элементов массива с помощью кучи */
+priority_queue<int, vector<int>, greater<int>> topKHeap(vector<int> &nums, int k) {
+    // Инициализация минимальной кучи
+    priority_queue<int, vector<int>, greater<int>> heap;
+    // Поместить первые k элементов массива в кучу
+    for (int i = 0; i < k; i++) {
+        heap.push(nums[i]);
+    }
+    // Начиная с элемента k+1, поддерживать длину кучи равной k
+    for (int i = k; i < nums.size(); i++) {
+        // Если текущий элемент больше элемента на вершине кучи, извлечь вершину кучи и добавить текущий элемент в кучу
+        if (nums[i] > heap.top()) {
+            heap.pop();
+            heap.push(nums[i]);
+        }
+    }
+    return heap;
+}
+
+// Driver Code
+int main() {
+    vector<int> nums = {1, 7, 6, 3, 2};
+    int k = 3;
+
+    priority_queue<int, vector<int>, greater<int>> res = topKHeap(nums, k);
+    cout << "Наибольшие " << k << " элементов: ";
+    printHeap(res);
+
+    return 0;
+}

ru/codes/cpp/chapter_searching/CMakeLists.txt

@@ -0,0 +1,4 @@
+add_executable(binary_search binary_search.cpp)
+add_executable(binary_search_insertion binary_search_insertion.cpp)
+add_executable(binary_search_edge binary_search_edge.cpp)
+add_executable(two_sum two_sum.cpp)

ru/codes/cpp/chapter_searching/binary_search.cpp

@@ -0,0 +1,59 @@
+/**
+ * File: binary_search.cpp
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Бинарный поиск (двусторонне замкнутый интервал) */
+int binarySearch(vector<int> &nums, int target) {
+    // Инициализировать двусторонне замкнутый интервал [0, n-1], то есть i и j указывают на первый и последний элементы массива соответственно
+    int i = 0, j = nums.size() - 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;
+}
+
+/* Бинарный поиск (лево замкнутый, право открытый интервал) */
+int binarySearchLCRO(vector<int> &nums, int target) {
+    // Инициализировать лево замкнутый, право открытый интервал [0, n), то есть i и j указывают на первый элемент массива и позицию сразу за последним элементом соответственно
+    int i = 0, j = nums.size();
+    // Цикл завершается, когда диапазон поиска пуст (при 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;
+}
+
+/* Driver Code */
+int main() {
+    int target = 6;
+    vector<int> nums = {1, 3, 6, 8, 12, 15, 23, 26, 31, 35};
+
+    /* Бинарный поиск (двусторонне замкнутый интервал) */
+    int index = binarySearch(nums, target);
+    cout << "Индекс целевого элемента 6 = " << index << endl;
+
+    /* Бинарный поиск (лево замкнутый, право открытый интервал) */
+    index = binarySearchLCRO(nums, target);
+    cout << "Индекс целевого элемента 6 = " << index << endl;
+
+    return 0;
+}

ru/codes/cpp/chapter_searching/binary_search_edge.cpp

@@ -0,0 +1,66 @@
+/**
+ * File: binary_search_edge.cpp
+ * Created Time: 2023-08-04
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Бинарный поиск точки вставки (с повторяющимися элементами) */
+int binarySearchInsertion(const vector<int> &nums, int target) {
+    int i = 0, j = nums.size() - 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 {
+            j = m - 1; // Первый элемент меньше target находится в интервале [i, m-1]
+        }
+    }
+    // Вернуть точку вставки i
+    return i;
+}
+
+/* Бинарный поиск самого левого target */
+int binarySearchLeftEdge(vector<int> &nums, int target) {
+    // Эквивалентно поиску точки вставки target
+    int i = binarySearchInsertion(nums, target);
+    // target не найден, вернуть -1
+    if (i == nums.size() || nums[i] != target) {
+        return -1;
+    }
+    // Найти target и вернуть индекс i
+    return i;
+}
+
+/* Бинарный поиск самого правого target */
+int binarySearchRightEdge(vector<int> &nums, int target) {
+    // Преобразовать задачу в поиск самого левого target + 1
+    int i = 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;
+}
+
+/* Driver Code */
+int main() {
+    // Массив с повторяющимися элементами
+    vector<int> nums = {1, 3, 6, 6, 6, 6, 6, 10, 12, 15};
+    cout << "\nМассив nums = ";
+    printVector(nums);
+
+    // Бинарный поиск левой и правой границы
+    for (int target : {6, 7}) {
+        int index = binarySearchLeftEdge(nums, target);
+        cout << "Индекс самого левого элемента " << target << " равен " << index << endl;
+        index = binarySearchRightEdge(nums, target);
+        cout << "Индекс самого правого элемента " << target << " равен " << index << endl;
+    }
+
+    return 0;
+}

ru/codes/cpp/chapter_searching/binary_search_insertion.cpp

@@ -0,0 +1,66 @@
+/**
+ * File: binary_search_insertion.cpp
+ * Created Time: 2023-08-04
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Бинарный поиск точки вставки (без повторяющихся элементов) */
+int binarySearchInsertionSimple(vector<int> &nums, int target) {
+    int i = 0, j = nums.size() - 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;
+}
+
+/* Бинарный поиск точки вставки (с повторяющимися элементами) */
+int binarySearchInsertion(vector<int> &nums, int target) {
+    int i = 0, j = nums.size() - 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;
+}
+
+/* Driver Code */
+int main() {
+    // Массив без повторяющихся элементов
+    vector<int> nums = {1, 3, 6, 8, 12, 15, 23, 26, 31, 35};
+    cout << "\nМассив nums = ";
+    printVector(nums);
+    // Бинарный поиск точки вставки
+    for (int target : {6, 9}) {
+        int index = binarySearchInsertionSimple(nums, target);
+        cout << "Индекс позиции вставки элемента " << target << " равен " << index << endl;
+    }
+
+    // Массив с повторяющимися элементами
+    nums = {1, 3, 6, 6, 6, 6, 6, 10, 12, 15};
+    cout << "\nМассив nums = ";
+    printVector(nums);
+    // Бинарный поиск точки вставки
+    for (int target : {2, 6, 20}) {
+        int index = binarySearchInsertion(nums, target);
+        cout << "Индекс позиции вставки элемента " << target << " равен " << index << endl;
+    }
+
+    return 0;
+}

ru/codes/cpp/chapter_searching/hashing_search.cpp

@@ -0,0 +1,53 @@
+/**
+ * File: hashing_search.cpp
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Хеш-поиск (массив) */
+int hashingSearchArray(unordered_map<int, int> map, int target) {
+    // key хеш-таблицы: целевой элемент, value: индекс
+    // Если такого key нет в хеш-таблице, вернуть -1
+    if (map.find(target) == map.end())
+        return -1;
+    return map[target];
+}
+
+/* Хеш-поиск (связный список) */
+ListNode *hashingSearchLinkedList(unordered_map<int, ListNode *> map, int target) {
+    // key хеш-таблицы: значение целевого узла, value: объект узла
+    // Если такого key нет в хеш-таблице, вернуть nullptr
+    if (map.find(target) == map.end())
+        return nullptr;
+    return map[target];
+}
+
+/* Driver Code */
+int main() {
+    int target = 3;
+
+    /* Хеш-поиск (массив) */
+    vector<int> nums = {1, 5, 3, 2, 4, 7, 5, 9, 10, 8};
+    // Инициализация хеш-таблицы
+    unordered_map<int, int> map;
+    for (int i = 0; i < nums.size(); i++) {
+        map[nums[i]] = i; // key: элемент, value: индекс
+    }
+    int index = hashingSearchArray(map, target);
+    cout << "Индекс целевого элемента 3 = " << index << endl;
+
+    /* Хеш-поиск (связный список) */
+    ListNode *head = vecToLinkedList(nums);
+    // Инициализация хеш-таблицы
+    unordered_map<int, ListNode *> map1;
+    while (head != nullptr) {
+        map1[head->val] = head; // key: значение узла, value: узел
+        head = head->next;
+    }
+    ListNode *node = hashingSearchLinkedList(map1, target);
+    cout << "Объект узла со значением 3 = " << node << endl;
+
+    return 0;
+}

ru/codes/cpp/chapter_searching/linear_search.cpp

@@ -0,0 +1,49 @@
+/**
+ * File: linear_search.cpp
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Линейный поиск (массив) */
+int linearSearchArray(vector<int> &nums, int target) {
+    // Обход массива
+    for (int i = 0; i < nums.size(); i++) {
+        // Целевой элемент найден, вернуть его индекс
+        if (nums[i] == target)
+            return i;
+    }
+    // Целевой элемент не найден, вернуть -1
+    return -1;
+}
+
+/* Линейный поиск (связный список) */
+ListNode *linearSearchLinkedList(ListNode *head, int target) {
+    // Обойти связный список
+    while (head != nullptr) {
+        // Найти целевой узел и вернуть его
+        if (head->val == target)
+            return head;
+        head = head->next;
+    }
+    // Целевой узел не найден, вернуть nullptr
+    return nullptr;
+}
+
+/* Driver Code */
+int main() {
+    int target = 3;
+
+    /* Выполнить линейный поиск в массиве */
+    vector<int> nums = {1, 5, 3, 2, 4, 7, 5, 9, 10, 8};
+    int index = linearSearchArray(nums, target);
+    cout << "Индекс целевого элемента 3 = " << index << endl;
+
+    /* Выполнить линейный поиск в связном списке */
+    ListNode *head = vecToLinkedList(nums);
+    ListNode *node = linearSearchLinkedList(head, target);
+    cout << "Объект узла со значением 3 = " << node << endl;
+
+    return 0;
+}

ru/codes/cpp/chapter_searching/two_sum.cpp

@@ -0,0 +1,54 @@
+/**
+ * File: two_sum.cpp
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Метод 1: полный перебор */
+vector<int> twoSumBruteForce(vector<int> &nums, int target) {
+    int size = nums.size();
+    // Два вложенных цикла, временная сложность 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 {i, j};
+        }
+    }
+    return {};
+}
+
+/* Метод 2: вспомогательная хеш-таблица */
+vector<int> twoSumHashTable(vector<int> &nums, int target) {
+    int size = nums.size();
+    // Вспомогательная хеш-таблица, пространственная сложность O(n)
+    unordered_map<int, int> dic;
+    // Один цикл, временная сложность O(n)
+    for (int i = 0; i < size; i++) {
+        if (dic.find(target - nums[i]) != dic.end()) {
+            return {dic[target - nums[i]], i};
+        }
+        dic.emplace(nums[i], i);
+    }
+    return {};
+}
+
+/* Driver Code */
+int main() {
+    // ======= Test Case =======
+    vector<int> nums = {2, 7, 11, 15};
+    int target = 13;
+
+    // ====== Основной код ======
+    // Метод 1
+    vector<int> res = twoSumBruteForce(nums, target);
+    cout << "Результат метода 1 res = ";
+    printVector(res);
+    // Метод 2
+    res = twoSumHashTable(nums, target);
+    cout << "Результат метода 2 res = ";
+    printVector(res);
+
+    return 0;
+}

ru/codes/cpp/chapter_sorting/CMakeLists.txt

@@ -0,0 +1,6 @@
+add_executable(selection_sort selection_sort.cpp)
+add_executable(bubble_sort bubble_sort.cpp)
+add_executable(insertion_sort insertion_sort.cpp)
+add_executable(merge_sort merge_sort.cpp)
+add_executable(quick_sort quick_sort.cpp)
+add_executable(heap_sort heap_sort.cpp)

ru/codes/cpp/chapter_sorting/bubble_sort.cpp

@@ -0,0 +1,56 @@
+/**
+ * File: bubble_sort.cpp
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Пузырьковая сортировка */
+void bubbleSort(vector<int> &nums) {
+    // Внешний цикл: неотсортированный диапазон [0, i]
+    for (int i = nums.size() - 1; i > 0; i--) {
+        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
+        for (int j = 0; j < i; j++) {
+            if (nums[j] > nums[j + 1]) {
+                // Поменять местами nums[j] и nums[j + 1]
+                // Здесь используется функция std::swap()
+                swap(nums[j], nums[j + 1]);
+            }
+        }
+    }
+}
+
+/* Пузырьковая сортировка (оптимизация флагом) */
+void bubbleSortWithFlag(vector<int> &nums) {
+    // Внешний цикл: неотсортированный диапазон [0, i]
+    for (int i = nums.size() - 1; i > 0; i--) {
+        bool flag = false; // Инициализировать флаг
+        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
+        for (int j = 0; j < i; j++) {
+            if (nums[j] > nums[j + 1]) {
+                // Поменять местами nums[j] и nums[j + 1]
+                // Здесь используется функция std::swap()
+                swap(nums[j], nums[j + 1]);
+                flag = true; // Записать обмен элементов
+            }
+        }
+        if (!flag)
+            break; // На этой итерации «всплытия» не было ни одного обмена, сразу выйти
+    }
+}
+
+/* Driver Code */
+int main() {
+    vector<int> nums = {4, 1, 3, 1, 5, 2};
+    bubbleSort(nums);
+    cout << "После пузырьковой сортировки nums = ";
+    printVector(nums);
+
+    vector<int> nums1 = {4, 1, 3, 1, 5, 2};
+    bubbleSortWithFlag(nums1);
+    cout << "После пузырьковой сортировки nums1 = ";
+    printVector(nums1);
+
+    return 0;
+}

ru/codes/cpp/chapter_sorting/bucket_sort.cpp

@@ -0,0 +1,44 @@
+/**
+ * File: bucket_sort.cpp
+ * Created Time: 2023-03-30
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Сортировка корзинами */
+void bucketSort(vector<float> &nums) {
+    // Инициализировать k = n/2 корзин, предполагая распределение 2 элементов в каждую корзину
+    int k = nums.size() / 2;
+    vector<vector<float>> buckets(k);
+    // 1. Распределить элементы массива по корзинам
+    for (float num : nums) {
+        // Входные данные лежат в диапазоне [0, 1); использовать num * k для отображения в диапазон индексов [0, k-1]
+        int i = num * k;
+        // Добавить num в корзину bucket_idx
+        buckets[i].push_back(num);
+    }
+    // 2. Выполнить сортировку внутри каждой корзины
+    for (vector<float> &bucket : buckets) {
+        // Использовать встроенную функцию сортировки; ее также можно заменить другим алгоритмом сортировки
+        sort(bucket.begin(), bucket.end());
+    }
+    // 3. Обойти корзины и объединить результаты
+    int i = 0;
+    for (vector<float> &bucket : buckets) {
+        for (float num : bucket) {
+            nums[i++] = num;
+        }
+    }
+}
+
+/* Driver Code */
+int main() {
+    // Пусть входные данные — числа с плавающей точкой из диапазона [0, 1)
+    vector<float> nums = {0.49f, 0.96f, 0.82f, 0.09f, 0.57f, 0.43f, 0.91f, 0.75f, 0.15f, 0.37f};
+    bucketSort(nums);
+    cout << "После сортировки корзинами nums = ";
+    printVector(nums);
+
+    return 0;
+}

ru/codes/cpp/chapter_sorting/counting_sort.cpp

@@ -0,0 +1,77 @@
+/**
+ * File: counting_sort.cpp
+ * Created Time: 2023-03-17
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Сортировка подсчетом */
+// Простая реализация, не подходит для сортировки объектов
+void countingSortNaive(vector<int> &nums) {
+    // 1. Найти максимальный элемент массива m
+    int m = 0;
+    for (int num : nums) {
+        m = max(m, num);
+    }
+    // 2. Подсчитать число появлений каждой цифры
+    // counter[num] обозначает число появлений num
+    vector<int> counter(m + 1, 0);
+    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;
+        }
+    }
+}
+
+/* Сортировка подсчетом */
+// Полная реализация, позволяет сортировать объекты и является стабильной сортировкой
+void countingSort(vector<int> &nums) {
+    // 1. Найти максимальный элемент массива m
+    int m = 0;
+    for (int num : nums) {
+        m = max(m, num);
+    }
+    // 2. Подсчитать число появлений каждой цифры
+    // counter[num] обозначает число появлений num
+    vector<int> counter(m + 1, 0);
+    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.size();
+    vector<int> res(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
+    nums = res;
+}
+
+/* Driver Code */
+int main() {
+    vector<int> nums = {1, 0, 1, 2, 0, 4, 0, 2, 2, 4};
+    countingSortNaive(nums);
+    cout << "После сортировки подсчетом (объекты не поддерживаются) nums = ";
+    printVector(nums);
+
+    vector<int> nums1 = {1, 0, 1, 2, 0, 4, 0, 2, 2, 4};
+    countingSort(nums1);
+    cout << "После сортировки подсчетом nums1 = ";
+    printVector(nums1);
+
+    return 0;
+}

ru/codes/cpp/chapter_sorting/heap_sort.cpp

@@ -0,0 +1,54 @@
+/**
+ * File: heap_sort.cpp
+ * Created Time: 2023-05-26
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Длина кучи равна n; начиная с узла i, выполнить просеивание сверху вниз */
+void siftDown(vector<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;
+        }
+        // Поменять два узла местами
+        swap(nums[i], nums[ma]);
+        // Циклическое просеивание вниз
+        i = ma;
+    }
+}
+
+/* Сортировка кучей */
+void heapSort(vector<int> &nums) {
+    // Построение кучи: выполнить heapify для всех узлов, кроме листовых
+    for (int i = nums.size() / 2 - 1; i >= 0; --i) {
+        siftDown(nums, nums.size(), i);
+    }
+    // Извлекать максимальный элемент из кучи в течение n-1 итераций
+    for (int i = nums.size() - 1; i > 0; --i) {
+        // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)
+        swap(nums[0], nums[i]);
+        // Начиная с корневого узла, выполнить просеивание сверху вниз
+        siftDown(nums, i, 0);
+    }
+}
+
+/* Driver Code */
+int main() {
+    vector<int> nums = {4, 1, 3, 1, 5, 2};
+    heapSort(nums);
+    cout << "После сортировки кучей nums = ";
+    printVector(nums);
+
+    return 0;
+}

ru/codes/cpp/chapter_sorting/insertion_sort.cpp

@@ -0,0 +1,31 @@
+/**
+ * File: insertion_sort.cpp
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Сортировка вставками */
+void insertionSort(vector<int> &nums) {
+    // Внешний цикл: отсортированный диапазон [0, i-1]
+    for (int i = 1; i < nums.size(); 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 в правильную позицию
+    }
+}
+
+/* Driver Code */
+int main() {
+    vector<int> nums = {4, 1, 3, 1, 5, 2};
+    insertionSort(nums);
+    cout << "После сортировки вставками nums = ";
+    printVector(nums);
+
+    return 0;
+}

ru/codes/cpp/chapter_sorting/merge_sort.cpp

@@ -0,0 +1,58 @@
+/**
+ * File: merge_sort.cpp
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Объединить левый и правый подмассивы */
+void merge(vector<int> &nums, int left, int mid, int right) {
+    // Диапазон левого подмассива: [left, mid], диапазон правого подмассива: [mid+1, right]
+    // Создать временный массив tmp для хранения результата слияния
+    vector<int> tmp(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.size(); k++) {
+        nums[left + k] = tmp[k];
+    }
+}
+
+/* Сортировка слиянием */
+void mergeSort(vector<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);
+}
+
+/* Driver Code */
+int main() {
+    /* Сортировка слиянием */
+    vector<int> nums = {7, 3, 2, 6, 0, 1, 5, 4};
+    mergeSort(nums, 0, nums.size() - 1);
+    cout << "После сортировки слиянием nums = ";
+    printVector(nums);
+
+    return 0;
+}

ru/codes/cpp/chapter_sorting/quick_sort.cpp

@@ -0,0 +1,145 @@
+/**
+ * File: quick_sort.cpp
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Класс быстрой сортировки */
+class QuickSort {
+  private:
+    /* Разбиение с опорными указателями */
+    static int partition(vector<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], nums[j]); // Поменять эти два элемента местами
+        }
+        swap(nums[i], nums[left]);  // Переместить опорный элемент на границу двух подмассивов
+        return i;                   // Вернуть индекс опорного элемента
+    }
+
+  public:
+    /* Быстрая сортировка */
+    static void quickSort(vector<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 {
+  private:
+    /* Выбрать медиану из трех кандидатов */
+    static int medianThree(vector<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(vector<int> &nums, int left, int right) {
+        // Выбрать медиану из трех кандидатов
+        int med = medianThree(nums, left, (left + right) / 2, right);
+        // Переместить медиану в крайний левый элемент массива
+        swap(nums[left], nums[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], nums[j]); // Поменять эти два элемента местами
+        }
+        swap(nums[i], nums[left]);  // Переместить опорный элемент на границу двух подмассивов
+        return i;                   // Вернуть индекс опорного элемента
+    }
+
+  public:
+    /* Быстрая сортировка */
+    static void quickSort(vector<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 {
+  private:
+    /* Разбиение с опорными указателями */
+    static int partition(vector<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], nums[j]); // Поменять эти два элемента местами
+        }
+        swap(nums[i], nums[left]);  // Переместить опорный элемент на границу двух подмассивов
+        return i;                   // Вернуть индекс опорного элемента
+    }
+
+  public:
+    /* Быстрая сортировка (оптимизация глубины рекурсии) */
+    static void quickSort(vector<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]
+            }
+        }
+    }
+};
+
+/* Driver Code */
+int main() {
+    /* Быстрая сортировка */
+    vector<int> nums{2, 4, 1, 0, 3, 5};
+    QuickSort::quickSort(nums, 0, nums.size() - 1);
+    cout << "После быстрой сортировки nums = ";
+    printVector(nums);
+
+    /* Быстрая сортировка (оптимизация медианным опорным элементом) */
+    vector<int> nums1 = {2, 4, 1, 0, 3, 5};
+    QuickSortMedian::quickSort(nums1, 0, nums1.size() - 1);
+    cout << "После быстрой сортировки (оптимизация медианным опорным элементом) nums = ";
+    printVector(nums1);
+
+    /* Быстрая сортировка (оптимизация глубины рекурсии) */
+    vector<int> nums2 = {2, 4, 1, 0, 3, 5};
+    QuickSortTailCall::quickSort(nums2, 0, nums2.size() - 1);
+    cout << "После быстрой сортировки (оптимизация глубины рекурсии) nums = ";
+    printVector(nums2);
+
+    return 0;
+}

ru/codes/cpp/chapter_sorting/radix_sort.cpp

@@ -0,0 +1,65 @@
+/**
+ * File: radix_sort.cpp
+ * Created Time: 2023-03-26
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Получить k-й разряд элемента num, где exp = 10^(k-1) */
+int digit(int num, int exp) {
+    // Передача exp вместо k позволяет избежать повторного дорогостоящего вычисления степени
+    return (num / exp) % 10;
+}
+
+/* Сортировка подсчетом (сортировка по k-му разряду nums) */
+void countingSortDigit(vector<int> &nums, int exp) {
+    // Разряды десятичной системы лежат в диапазоне 0~9, поэтому нужен массив корзин длины 10
+    vector<int> counter(10, 0);
+    int n = nums.size();
+    // Подсчитать число появлений каждой цифры от 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 элементами по статистике в корзинах
+    vector<int> res(n, 0);
+    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];
+}
+
+/* Поразрядная сортировка */
+void radixSort(vector<int> &nums) {
+    // Получить максимальный элемент массива, чтобы определить максимальное число разрядов
+    int m = *max_element(nums.begin(), nums.end());
+    // Проходить разряды от младшего к старшему
+    for (int exp = 1; exp <= m; exp *= 10)
+        // Выполнить сортировку подсчетом по k-му разряду элементов массива
+        // k = 1 -> exp = 1
+        // k = 2 -> exp = 10
+        // то есть exp = 10^(k-1)
+        countingSortDigit(nums, exp);
+}
+
+/* Driver Code */
+int main() {
+    // Поразрядная сортировка
+    vector<int> nums = {10546151, 35663510, 42865989, 34862445, 81883077,
+                        88906420, 72429244, 30524779, 82060337, 63832996};
+    radixSort(nums);
+    cout << "После поразрядной сортировки nums = ";
+    printVector(nums);
+
+    return 0;
+}

ru/codes/cpp/chapter_sorting/selection_sort.cpp

@@ -0,0 +1,34 @@
+/**
+ * File: selection_sort.cpp
+ * Created Time: 2023-05-23
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Сортировка выбором */
+void selectionSort(vector<int> &nums) {
+    int n = nums.size();
+    // Внешний цикл: неотсортированный диапазон [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; // Записать индекс минимального элемента
+        }
+        // Поменять этот минимальный элемент местами с первым элементом неотсортированного диапазона
+        swap(nums[i], nums[k]);
+    }
+}
+
+/* Driver Code */
+int main() {
+    vector<int> nums = {4, 1, 3, 1, 5, 2};
+    selectionSort(nums);
+
+    cout << "После сортировки выбором nums = ";
+    printVector(nums);
+
+    return 0;
+}

ru/codes/cpp/chapter_stack_and_queue/CMakeLists.txt

@@ -0,0 +1,9 @@
+add_executable(array_deque array_deque.cpp)
+add_executable(array_queue array_queue.cpp)
+add_executable(array_stack array_stack.cpp)
+add_executable(deque deque.cpp)
+add_executable(linkedlist_deque linkedlist_deque.cpp)
+add_executable(linkedlist_queue linkedlist_queue.cpp)
+add_executable(linkedlist_stack linkedlist_stack.cpp)
+add_executable(queue queue.cpp)
+add_executable(stack stack.cpp)

ru/codes/cpp/chapter_stack_and_queue/array_deque.cpp

@@ -0,0 +1,156 @@
+/**
+ * File: array_deque.cpp
+ * Created Time: 2023-03-02
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Двусторонняя очередь на основе кольцевого массива */
+class ArrayDeque {
+  private:
+    vector<int> nums; // Массив для хранения элементов двусторонней очереди
+    int front;        // Указатель head, указывающий на первый элемент очереди
+    int queSize;      // Длина двусторонней очереди
+
+  public:
+    /* Конструктор */
+    ArrayDeque(int capacity) {
+        nums.resize(capacity);
+        front = queSize = 0;
+    }
+
+    /* Получить вместимость двусторонней очереди */
+    int capacity() {
+        return nums.size();
+    }
+
+    /* Получение длины двусторонней очереди */
+    int size() {
+        return queSize;
+    }
+
+    /* Проверка, пуста ли двусторонняя очередь */
+    bool isEmpty() {
+        return queSize == 0;
+    }
+
+    /* Вычислить индекс в кольцевом массиве */
+    int index(int i) {
+        // С помощью операции взятия по модулю соединить начало и конец массива
+        // Когда i выходит за конец массива, он возвращается в начало
+        // Когда i выходит за начало массива, он возвращается в конец
+        return (i + capacity()) % capacity();
+    }
+
+    /* Добавление в голову очереди */
+    void pushFirst(int num) {
+        if (queSize == capacity()) {
+            cout << "Двусторонняя очередь заполнена" << endl;
+            return;
+        }
+        // Указатель головы сдвигается на одну позицию влево
+        // С помощью операции взятия по модулю front после выхода за начало массива возвращается в хвост
+        front = index(front - 1);
+        // Добавить num в голову очереди
+        nums[front] = num;
+        queSize++;
+    }
+
+    /* Добавление в хвост очереди */
+    void pushLast(int num) {
+        if (queSize == capacity()) {
+            cout << "Двусторонняя очередь заполнена" << endl;
+            return;
+        }
+        // Вычислить указатель хвоста, указывающий на индекс хвоста + 1
+        int rear = index(front + queSize);
+        // Добавить num в хвост очереди
+        nums[rear] = num;
+        queSize++;
+    }
+
+    /* Извлечение из головы очереди */
+    int popFirst() {
+        int num = peekFirst();
+        // Указатель головы сдвигается на одну позицию назад
+        front = index(front + 1);
+        queSize--;
+        return num;
+    }
+
+    /* Извлечение из хвоста очереди */
+    int popLast() {
+        int num = peekLast();
+        queSize--;
+        return num;
+    }
+
+    /* Доступ к элементу в начале очереди */
+    int peekFirst() {
+        if (isEmpty())
+            throw out_of_range("двусторонняя очередь пуста");
+        return nums[front];
+    }
+
+    /* Доступ к элементу в конце очереди */
+    int peekLast() {
+        if (isEmpty())
+            throw out_of_range("двусторонняя очередь пуста");
+        // Вычислить индекс хвостового элемента
+        int last = index(front + queSize - 1);
+        return nums[last];
+    }
+
+    /* Вернуть массив для вывода */
+    vector<int> toVector() {
+        // Преобразовывать только элементы списка в пределах фактической длины
+        vector<int> res(queSize);
+        for (int i = 0, j = front; i < queSize; i++, j++) {
+            res[i] = nums[index(j)];
+        }
+        return res;
+    }
+};
+
+/* Driver Code */
+int main() {
+    /* Инициализация двусторонней очереди */
+    ArrayDeque *deque = new ArrayDeque(10);
+    deque->pushLast(3);
+    deque->pushLast(2);
+    deque->pushLast(5);
+    cout << "Двусторонняя очередь deque = ";
+    printVector(deque->toVector());
+
+    /* Доступ к элементу */
+    int peekFirst = deque->peekFirst();
+    cout << "Первый элемент peekFirst = " << peekFirst << endl;
+    int peekLast = deque->peekLast();
+    cout << "Последний элемент peekLast = " << peekLast << endl;
+
+    /* Добавление элемента в очередь */
+    deque->pushLast(4);
+    cout << "После добавления элемента 4 в хвост deque = ";
+    printVector(deque->toVector());
+    deque->pushFirst(1);
+    cout << "После добавления элемента 1 в голову deque = ";
+    printVector(deque->toVector());
+
+    /* Извлечение элемента из очереди */
+    int popLast = deque->popLast();
+    cout << "Извлеченный из хвоста элемент = " << popLast << ", deque после извлечения из хвоста = ";
+    printVector(deque->toVector());
+    int popFirst = deque->popFirst();
+    cout << "Извлеченный из головы элемент = " << popFirst << ", deque после извлечения из головы = ";
+    printVector(deque->toVector());
+
+    /* Получение длины двусторонней очереди */
+    int size = deque->size();
+    cout << "Длина двусторонней очереди size = " << size << endl;
+
+    /* Проверка, пуста ли двусторонняя очередь */
+    bool isEmpty = deque->isEmpty();
+    cout << "Пуста ли двусторонняя очередь = " << boolalpha << isEmpty << endl;
+    return 0;
+}

ru/codes/cpp/chapter_stack_and_queue/array_queue.cpp

@@ -0,0 +1,129 @@
+/**
+ * File: array_queue.cpp
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Очередь на основе кольцевого массива */
+class ArrayQueue {
+  private:
+    int *nums;       // Массив для хранения элементов очереди
+    int front;       // Указатель head, указывающий на первый элемент очереди
+    int queSize;     // Длина очереди
+    int queCapacity; // Вместимость очереди
+
+  public:
+    ArrayQueue(int capacity) {
+        // Инициализация массива
+        nums = new int[capacity];
+        queCapacity = capacity;
+        front = queSize = 0;
+    }
+
+    ~ArrayQueue() {
+        delete[] nums;
+    }
+
+    /* Получить вместимость очереди */
+    int capacity() {
+        return queCapacity;
+    }
+
+    /* Получение длины очереди */
+    int size() {
+        return queSize;
+    }
+
+    /* Проверка, пуста ли очередь */
+    bool isEmpty() {
+        return size() == 0;
+    }
+
+    /* Поместить в очередь */
+    void push(int num) {
+        if (queSize == queCapacity) {
+            cout << "Очередь заполнена" << endl;
+            return;
+        }
+        // Вычислить указатель хвоста, указывающий на индекс хвоста + 1
+        // С помощью операции взятия по модулю вернуть rear к началу после выхода за конец массива
+        int rear = (front + queSize) % queCapacity;
+        // Добавить num в хвост очереди
+        nums[rear] = num;
+        queSize++;
+    }
+
+    /* Извлечь из очереди */
+    int pop() {
+        int num = peek();
+        // Указатель head сдвигается на одну позицию назад; если он выходит за конец, то возвращается в начало массива
+        front = (front + 1) % queCapacity;
+        queSize--;
+        return num;
+    }
+
+    /* Доступ к элементу в начале очереди */
+    int peek() {
+        if (isEmpty())
+            throw out_of_range("очередь пуста");
+        return nums[front];
+    }
+
+    /* Преобразовать массив в Vector и вернуть */
+    vector<int> toVector() {
+        // Преобразовывать только элементы списка в пределах фактической длины
+        vector<int> arr(queSize);
+        for (int i = 0, j = front; i < queSize; i++, j++) {
+            arr[i] = nums[j % queCapacity];
+        }
+        return arr;
+    }
+};
+
+/* Driver Code */
+int main() {
+    /* Инициализация очереди */
+    int capacity = 10;
+    ArrayQueue *queue = new ArrayQueue(capacity);
+
+    /* Добавление элемента в очередь */
+    queue->push(1);
+    queue->push(3);
+    queue->push(2);
+    queue->push(5);
+    queue->push(4);
+    cout << "Очередь queue = ";
+    printVector(queue->toVector());
+
+    /* Доступ к элементу в начале очереди */
+    int peek = queue->peek();
+    cout << "Первый элемент peek = " << peek << endl;
+
+    /* Извлечение элемента из очереди */
+    peek = queue->pop();
+    cout << "Извлеченный элемент pop = " << peek << ", queue после извлечения = ";
+    printVector(queue->toVector());
+
+    /* Получение длины очереди */
+    int size = queue->size();
+    cout << "Длина очереди size = " << size << endl;
+
+    /* Проверка, пуста ли очередь */
+    bool empty = queue->isEmpty();
+    cout << "Пуста ли очередь = " << empty << endl;
+
+    /* Проверка кольцевого массива */
+    for (int i = 0; i < 10; i++) {
+        queue->push(i);
+        queue->pop();
+        cout << "После " << i << "-го раунда операций enqueue и dequeue queue = ";
+        printVector(queue->toVector());
+    }
+
+    // Освободить память
+    delete queue;
+
+    return 0;
+}

ru/codes/cpp/chapter_stack_and_queue/array_stack.cpp

@@ -0,0 +1,85 @@
+/**
+ * File: array_stack.cpp
+ * Created Time: 2022-11-28
+ * Author: qualifier1024 (2539244001@qq.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Стек на основе массива */
+class ArrayStack {
+  private:
+    vector<int> stack;
+
+  public:
+    /* Получение длины стека */
+    int size() {
+        return stack.size();
+    }
+
+    /* Проверка, пуст ли стек */
+    bool isEmpty() {
+        return stack.size() == 0;
+    }
+
+    /* Поместить в стек */
+    void push(int num) {
+        stack.push_back(num);
+    }
+
+    /* Извлечь из стека */
+    int pop() {
+        int num = top();
+        stack.pop_back();
+        return num;
+    }
+
+    /* Доступ к верхнему элементу стека */
+    int top() {
+        if (isEmpty())
+            throw out_of_range("стек пуст");
+        return stack.back();
+    }
+
+    /* Вернуть Vector */
+    vector<int> toVector() {
+        return stack;
+    }
+};
+
+/* Driver Code */
+int main() {
+    /* Инициализация стека */
+    ArrayStack *stack = new ArrayStack();
+
+    /* Помещение элемента в стек */
+    stack->push(1);
+    stack->push(3);
+    stack->push(2);
+    stack->push(5);
+    stack->push(4);
+    cout << "Стек stack = ";
+    printVector(stack->toVector());
+
+    /* Доступ к верхнему элементу стека */
+    int top = stack->top();
+    cout << "Верхний элемент top = " << top << endl;
+
+    /* Извлечение элемента из стека */
+    top = stack->pop();
+    cout << "Извлеченный элемент pop = " << top << ", stack после извлечения = ";
+    printVector(stack->toVector());
+
+    /* Получение длины стека */
+    int size = stack->size();
+    cout << "Длина стека size = " << size << endl;
+
+    /* Проверка на пустоту */
+    bool empty = stack->isEmpty();
+    cout << "Пуст ли стек = " << empty << endl;
+
+    // Освободить память
+    delete stack;
+
+    return 0;
+}

ru/codes/cpp/chapter_stack_and_queue/deque.cpp

@@ -0,0 +1,46 @@
+/**
+ * File: deque.cpp
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Driver Code */
+int main() {
+    /* Инициализация двусторонней очереди */
+    deque<int> deque;
+
+    /* Добавление элемента в очередь */
+    deque.push_back(2);
+    deque.push_back(5);
+    deque.push_back(4);
+    deque.push_front(3);
+    deque.push_front(1);
+    cout << "Двусторонняя очередь deque = ";
+    printDeque(deque);
+
+    /* Доступ к элементу */
+    int front = deque.front();
+    cout << "Первый элемент front = " << front << endl;
+    int back = deque.back();
+    cout << "Последний элемент back = " << back << endl;
+
+    /* Извлечение элемента из очереди */
+    deque.pop_front();
+    cout << "Извлеченный из головы элемент popFront = " << front << ", deque после извлечения из головы = ";
+    printDeque(deque);
+    deque.pop_back();
+    cout << "Извлеченный из хвоста элемент popLast = " << back << ", deque после извлечения из хвоста = ";
+    printDeque(deque);
+
+    /* Получение длины двусторонней очереди */
+    int size = deque.size();
+    cout << "Длина двусторонней очереди size = " << size << endl;
+
+    /* Проверка, пуста ли двусторонняя очередь */
+    bool empty = deque.empty();
+    cout << "Пуста ли двусторонняя очередь = " << empty << endl;
+
+    return 0;
+}

ru/codes/cpp/chapter_stack_and_queue/linkedlist_deque.cpp

@@ -0,0 +1,194 @@
+/**
+ * File: linkedlist_deque.cpp
+ * Created Time: 2023-03-02
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Узел двусвязного списка */
+struct DoublyListNode {
+    int val;              // Значение узла
+    DoublyListNode *next; // Указатель на узел-преемник
+    DoublyListNode *prev; // Указатель на узел-предшественник
+    DoublyListNode(int val) : val(val), prev(nullptr), next(nullptr) {
+    }
+};
+
+/* Двусторонняя очередь на основе двусвязного списка */
+class LinkedListDeque {
+  private:
+    DoublyListNode *front, *rear; // Головной узел front, хвостовой узел rear
+    int queSize = 0;              // Длина двусторонней очереди
+
+  public:
+    /* Конструктор */
+    LinkedListDeque() : front(nullptr), rear(nullptr) {
+    }
+
+    /* Метод-деструктор */
+    ~LinkedListDeque() {
+        // Обходить связный список, удалять узлы и освобождать память
+        DoublyListNode *pre, *cur = front;
+        while (cur != nullptr) {
+            pre = cur;
+            cur = cur->next;
+            delete pre;
+        }
+    }
+
+    /* Получение длины двусторонней очереди */
+    int size() {
+        return queSize;
+    }
+
+    /* Проверка, пуста ли двусторонняя очередь */
+    bool isEmpty() {
+        return size() == 0;
+    }
+
+    /* Операция добавления в очередь */
+    void push(int num, bool isFront) {
+        DoublyListNode *node = new DoublyListNode(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++; // Обновить длину очереди
+    }
+
+    /* Добавление в голову очереди */
+    void pushFirst(int num) {
+        push(num, true);
+    }
+
+    /* Добавление в хвост очереди */
+    void pushLast(int num) {
+        push(num, false);
+    }
+
+    /* Операция извлечения из очереди */
+    int pop(bool isFront) {
+        if (isEmpty())
+            throw out_of_range("очередь пуста");
+        int val;
+        // Операция извлечения из головы очереди
+        if (isFront) {
+            val = front->val; // Временно сохранить значение головного узла
+            // Удалить головной узел
+            DoublyListNode *fNext = front->next;
+            if (fNext != nullptr) {
+                fNext->prev = nullptr;
+                front->next = nullptr;
+            }
+            delete front;
+            front = fNext; // Обновить головной узел
+        // Операция извлечения из хвоста очереди
+        } else {
+            val = rear->val; // Временно сохранить значение хвостового узла
+            // Удалить хвостовой узел
+            DoublyListNode *rPrev = rear->prev;
+            if (rPrev != nullptr) {
+                rPrev->next = nullptr;
+                rear->prev = nullptr;
+            }
+            delete rear;
+            rear = rPrev; // Обновить хвостовой узел
+        }
+        queSize--; // Обновить длину очереди
+        return val;
+    }
+
+    /* Извлечение из головы очереди */
+    int popFirst() {
+        return pop(true);
+    }
+
+    /* Извлечение из хвоста очереди */
+    int popLast() {
+        return pop(false);
+    }
+
+    /* Доступ к элементу в начале очереди */
+    int peekFirst() {
+        if (isEmpty())
+            throw out_of_range("двусторонняя очередь пуста");
+        return front->val;
+    }
+
+    /* Доступ к элементу в конце очереди */
+    int peekLast() {
+        if (isEmpty())
+            throw out_of_range("двусторонняя очередь пуста");
+        return rear->val;
+    }
+
+    /* Вернуть массив для вывода */
+    vector<int> toVector() {
+        DoublyListNode *node = front;
+        vector<int> res(size());
+        for (int i = 0; i < res.size(); i++) {
+            res[i] = node->val;
+            node = node->next;
+        }
+        return res;
+    }
+};
+
+/* Driver Code */
+int main() {
+    /* Инициализация двусторонней очереди */
+    LinkedListDeque *deque = new LinkedListDeque();
+    deque->pushLast(3);
+    deque->pushLast(2);
+    deque->pushLast(5);
+    cout << "Двусторонняя очередь deque = ";
+    printVector(deque->toVector());
+
+    /* Доступ к элементу */
+    int peekFirst = deque->peekFirst();
+    cout << "Первый элемент peekFirst = " << peekFirst << endl;
+    int peekLast = deque->peekLast();
+    cout << "Последний элемент peekLast = " << peekLast << endl;
+
+    /* Добавление элемента в очередь */
+    deque->pushLast(4);
+    cout << "После добавления элемента 4 в хвост deque =";
+    printVector(deque->toVector());
+    deque->pushFirst(1);
+    cout << "После добавления элемента 1 в голову deque = ";
+    printVector(deque->toVector());
+
+    /* Извлечение элемента из очереди */
+    int popLast = deque->popLast();
+    cout << "Извлеченный из хвоста элемент = " << popLast << ", deque после извлечения из хвоста = ";
+    printVector(deque->toVector());
+    int popFirst = deque->popFirst();
+    cout << "Извлеченный из головы элемент = " << popFirst << ", deque после извлечения из головы = ";
+    printVector(deque->toVector());
+
+    /* Получение длины двусторонней очереди */
+    int size = deque->size();
+    cout << "Длина двусторонней очереди size = " << size << endl;
+
+    /* Проверка, пуста ли двусторонняя очередь */
+    bool isEmpty = deque->isEmpty();
+    cout << "Пуста ли двусторонняя очередь = " << boolalpha << isEmpty << endl;
+
+    // Освободить память
+    delete deque;
+
+    return 0;
+}

ru/codes/cpp/chapter_stack_and_queue/linkedlist_queue.cpp

@@ -0,0 +1,120 @@
+/**
+ * File: linkedlist_queue.cpp
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Очередь на основе связного списка */
+class LinkedListQueue {
+  private:
+    ListNode *front, *rear; // Головной узел front, хвостовой узел rear
+    int queSize;
+
+  public:
+    LinkedListQueue() {
+        front = nullptr;
+        rear = nullptr;
+        queSize = 0;
+    }
+
+    ~LinkedListQueue() {
+        // Обходить связный список, удалять узлы и освобождать память
+        freeMemoryLinkedList(front);
+    }
+
+    /* Получение длины очереди */
+    int size() {
+        return queSize;
+    }
+
+    /* Проверка, пуста ли очередь */
+    bool isEmpty() {
+        return queSize == 0;
+    }
+
+    /* Поместить в очередь */
+    void push(int num) {
+        // Добавить num после хвостового узла
+        ListNode *node = new ListNode(num);
+        // Если очередь пуста, сделать так, чтобы и head, и tail указывали на этот узел
+        if (front == nullptr) {
+            front = node;
+            rear = node;
+        }
+        // Если очередь не пуста, добавить этот узел после хвостового узла
+        else {
+            rear->next = node;
+            rear = node;
+        }
+        queSize++;
+    }
+
+    /* Извлечь из очереди */
+    int pop() {
+        int num = peek();
+        // Удалить головной узел
+        ListNode *tmp = front;
+        front = front->next;
+        // Освободить память
+        delete tmp;
+        queSize--;
+        return num;
+    }
+
+    /* Доступ к элементу в начале очереди */
+    int peek() {
+        if (size() == 0)
+            throw out_of_range("очередь пуста");
+        return front->val;
+    }
+
+    /* Преобразовать связный список в Vector и вернуть */
+    vector<int> toVector() {
+        ListNode *node = front;
+        vector<int> res(size());
+        for (int i = 0; i < res.size(); i++) {
+            res[i] = node->val;
+            node = node->next;
+        }
+        return res;
+    }
+};
+
+/* Driver Code */
+int main() {
+    /* Инициализация очереди */
+    LinkedListQueue *queue = new LinkedListQueue();
+
+    /* Добавление элемента в очередь */
+    queue->push(1);
+    queue->push(3);
+    queue->push(2);
+    queue->push(5);
+    queue->push(4);
+    cout << "Очередь queue = ";
+    printVector(queue->toVector());
+
+    /* Доступ к элементу в начале очереди */
+    int peek = queue->peek();
+    cout << "Первый элемент peek = " << peek << endl;
+
+    /* Извлечение элемента из очереди */
+    peek = queue->pop();
+    cout << "Извлеченный элемент pop = " << peek << ", queue после извлечения = ";
+    printVector(queue->toVector());
+
+    /* Получение длины очереди */
+    int size = queue->size();
+    cout << "Длина очереди size = " << size << endl;
+
+    /* Проверка, пуста ли очередь */
+    bool empty = queue->isEmpty();
+    cout << "Пуста ли очередь = " << empty << endl;
+
+    // Освободить память
+    delete queue;
+
+    return 0;
+}

ru/codes/cpp/chapter_stack_and_queue/linkedlist_stack.cpp

@@ -0,0 +1,109 @@
+/**
+ * File: linkedlist_stack.cpp
+ * Created Time: 2022-11-28
+ * Author: qualifier1024 (2539244001@qq.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Стек на основе связного списка */
+class LinkedListStack {
+  private:
+    ListNode *stackTop; // Использовать головной узел как вершину стека
+    int stkSize;        // Длина стека
+
+  public:
+    LinkedListStack() {
+        stackTop = nullptr;
+        stkSize = 0;
+    }
+
+    ~LinkedListStack() {
+        // Обходить связный список, удалять узлы и освобождать память
+        freeMemoryLinkedList(stackTop);
+    }
+
+    /* Получение длины стека */
+    int size() {
+        return stkSize;
+    }
+
+    /* Проверка, пуст ли стек */
+    bool isEmpty() {
+        return size() == 0;
+    }
+
+    /* Поместить в стек */
+    void push(int num) {
+        ListNode *node = new ListNode(num);
+        node->next = stackTop;
+        stackTop = node;
+        stkSize++;
+    }
+
+    /* Извлечь из стека */
+    int pop() {
+        int num = top();
+        ListNode *tmp = stackTop;
+        stackTop = stackTop->next;
+        // Освободить память
+        delete tmp;
+        stkSize--;
+        return num;
+    }
+
+    /* Доступ к верхнему элементу стека */
+    int top() {
+        if (isEmpty())
+            throw out_of_range("стек пуст");
+        return stackTop->val;
+    }
+
+    /* Преобразовать List в Array и вернуть */
+    vector<int> toVector() {
+        ListNode *node = stackTop;
+        vector<int> res(size());
+        for (int i = res.size() - 1; i >= 0; i--) {
+            res[i] = node->val;
+            node = node->next;
+        }
+        return res;
+    }
+};
+
+/* Driver Code */
+int main() {
+    /* Инициализация стека */
+    LinkedListStack *stack = new LinkedListStack();
+
+    /* Помещение элемента в стек */
+    stack->push(1);
+    stack->push(3);
+    stack->push(2);
+    stack->push(5);
+    stack->push(4);
+    cout << "Стек stack = ";
+    printVector(stack->toVector());
+
+    /* Доступ к верхнему элементу стека */
+    int top = stack->top();
+    cout << "Верхний элемент top = " << top << endl;
+
+    /* Извлечение элемента из стека */
+    top = stack->pop();
+    cout << "Извлеченный элемент pop = " << top << ", stack после извлечения = ";
+    printVector(stack->toVector());
+
+    /* Получение длины стека */
+    int size = stack->size();
+    cout << "Длина стека size = " << size << endl;
+
+    /* Проверка на пустоту */
+    bool empty = stack->isEmpty();
+    cout << "Пуст ли стек = " << empty << endl;
+
+    // Освободить память
+    delete stack;
+
+    return 0;
+}

ru/codes/cpp/chapter_stack_and_queue/queue.cpp

@@ -0,0 +1,41 @@
+/**
+ * File: queue.cpp
+ * Created Time: 2022-11-28
+ * Author: qualifier1024 (2539244001@qq.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Driver Code */
+int main() {
+    /* Инициализация очереди */
+    queue<int> queue;
+
+    /* Добавление элемента в очередь */
+    queue.push(1);
+    queue.push(3);
+    queue.push(2);
+    queue.push(5);
+    queue.push(4);
+    cout << "Очередь queue = ";
+    printQueue(queue);
+
+    /* Доступ к элементу в начале очереди */
+    int front = queue.front();
+    cout << "Первый элемент front = " << front << endl;
+
+    /* Извлечение элемента из очереди */
+    queue.pop();
+    cout << "Извлеченный элемент front = " << front << ", queue после извлечения = ";
+    printQueue(queue);
+
+    /* Получение длины очереди */
+    int size = queue.size();
+    cout << "Длина очереди size = " << size << endl;
+
+    /* Проверка, пуста ли очередь */
+    bool empty = queue.empty();
+    cout << "Пуста ли очередь = " << empty << endl;
+
+    return 0;
+}

ru/codes/cpp/chapter_stack_and_queue/stack.cpp

@@ -0,0 +1,41 @@
+/**
+ * File: stack.cpp
+ * Created Time: 2022-11-28
+ * Author: qualifier1024 (2539244001@qq.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Driver Code */
+int main() {
+    /* Инициализация стека */
+    stack<int> stack;
+
+    /* Помещение элемента в стек */
+    stack.push(1);
+    stack.push(3);
+    stack.push(2);
+    stack.push(5);
+    stack.push(4);
+    cout << "Стек stack = ";
+    printStack(stack);
+
+    /* Доступ к верхнему элементу стека */
+    int top = stack.top();
+    cout << "Верхний элемент top = " << top << endl;
+
+    /* Извлечение элемента из стека */
+    stack.pop(); // Без возвращаемого значения
+    cout << "Извлеченный элемент pop = " << top << ", stack после извлечения = ";
+    printStack(stack);
+
+    /* Получение длины стека */
+    int size = stack.size();
+    cout << "Длина стека size = " << size << endl;
+
+    /* Проверка на пустоту */
+    bool empty = stack.empty();
+    cout << "Пуст ли стек = " << empty << endl;
+
+    return 0;
+}

ru/codes/cpp/chapter_tree/CMakeLists.txt

@@ -0,0 +1,6 @@
+add_executable(avl_tree avl_tree.cpp)
+add_executable(binary_search_tree binary_search_tree.cpp)
+add_executable(binary_tree binary_tree.cpp)
+add_executable(binary_tree_bfs binary_tree_bfs.cpp)
+add_executable(binary_tree_dfs binary_tree_dfs.cpp)
+add_executable(array_binary_tree array_binary_tree.cpp)

ru/codes/cpp/chapter_tree/array_binary_tree.cpp

@@ -0,0 +1,137 @@
+/**
+ * File: array_binary_tree.cpp
+ * Created Time: 2023-07-19
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Класс двоичного дерева в массивном представлении */
+class ArrayBinaryTree {
+  public:
+    /* Конструктор */
+    ArrayBinaryTree(vector<int> arr) {
+        tree = arr;
+    }
+
+    /* Вместимость списка */
+    int size() {
+        return tree.size();
+    }
+
+    /* Получить значение узла с индексом i */
+    int val(int i) {
+        // Если индекс выходит за границы, вернуть INT_MAX, обозначающий пустую позицию
+        if (i < 0 || i >= size())
+            return INT_MAX;
+        return tree[i];
+    }
+
+    /* Получить индекс левого дочернего узла узла с индексом i */
+    int left(int i) {
+        return 2 * i + 1;
+    }
+
+    /* Получить индекс правого дочернего узла узла с индексом i */
+    int right(int i) {
+        return 2 * i + 2;
+    }
+
+    /* Получить индекс родительского узла узла с индексом i */
+    int parent(int i) {
+        return (i - 1) / 2;
+    }
+
+    /* Обход в ширину */
+    vector<int> levelOrder() {
+        vector<int> res;
+        // Непосредственно обходить массив
+        for (int i = 0; i < size(); i++) {
+            if (val(i) != INT_MAX)
+                res.push_back(val(i));
+        }
+        return res;
+    }
+
+    /* Предварительный обход */
+    vector<int> preOrder() {
+        vector<int> res;
+        dfs(0, "pre", res);
+        return res;
+    }
+
+    /* Симметричный обход */
+    vector<int> inOrder() {
+        vector<int> res;
+        dfs(0, "in", res);
+        return res;
+    }
+
+    /* Обратный обход */
+    vector<int> postOrder() {
+        vector<int> res;
+        dfs(0, "post", res);
+        return res;
+    }
+
+  private:
+    vector<int> tree;
+
+    /* Обход в глубину */
+    void dfs(int i, string order, vector<int> &res) {
+        // Если это пустая позиция, вернуть
+        if (val(i) == INT_MAX)
+            return;
+        // Предварительный обход
+        if (order == "pre")
+            res.push_back(val(i));
+        dfs(left(i), order, res);
+        // Симметричный обход
+        if (order == "in")
+            res.push_back(val(i));
+        dfs(right(i), order, res);
+        // Обратный обход
+        if (order == "post")
+            res.push_back(val(i));
+    }
+};
+
+/* Driver Code */
+int main() {
+    // Инициализировать двоичное дерево
+    // Использовать INT_MAX для обозначения пустой позиции nullptr
+    vector<int> arr = {1, 2, 3, 4, INT_MAX, 6, 7, 8, 9, INT_MAX, INT_MAX, 12, INT_MAX, INT_MAX, 15};
+    TreeNode *root = vectorToTree(arr);
+    cout << "\nИнициализация двоичного дерева\n";
+    cout << "Массивное представление двоичного дерева:\n";
+    printVector(arr);
+    cout << "Связное представление двоичного дерева:\n";
+    printTree(root);
+
+    // Класс двоичного дерева в массивном представлении
+    ArrayBinaryTree abt(arr);
+
+    // Доступ к узлу
+    int i = 1;
+    int l = abt.left(i), r = abt.right(i), p = abt.parent(i);
+    cout << "\nТекущий узел: индекс = " << i << ", значение = " << abt.val(i) << "\n";
+    cout << "Индекс левого дочернего узла = " << l << ", значение = " << (abt.val(l) != INT_MAX ? to_string(abt.val(l)) : "nullptr") << "\n";
+    cout << "Индекс правого дочернего узла = " << r << ", значение = " << (abt.val(r) != INT_MAX ? to_string(abt.val(r)) : "nullptr") << "\n";
+    cout << "Индекс родительского узла = " << p << ", значение = " << (abt.val(p) != INT_MAX ? to_string(abt.val(p)) : "nullptr") << "\n";
+
+    // Обходить дерево
+    vector<int> res = abt.levelOrder();
+    cout << "\nОбход в ширину: ";
+    printVector(res);
+    res = abt.preOrder();
+    cout << "Предварительный обход: ";
+    printVector(res);
+    res = abt.inOrder();
+    cout << "Симметричный обход: ";
+    printVector(res);
+    res = abt.postOrder();
+    cout << "Обратный обход: ";
+    printVector(res);
+
+    return 0;
+}

ru/codes/cpp/chapter_tree/avl_tree.cpp

@@ -0,0 +1,233 @@
+/**
+ * File: avl_tree.cpp
+ * Created Time: 2023-02-03
+ * Author: what-is-me (whatisme@outlook.jp)
+ */
+
+#include "../utils/common.hpp"
+
+/* AVL-дерево */
+class AVLTree {
+  private:
+    /* Обновить высоту узла */
+    void updateHeight(TreeNode *node) {
+        // Высота узла равна высоте более высокого поддерева + 1
+        node->height = max(height(node->left), height(node->right)) + 1;
+    }
+
+    /* Операция правого вращения */
+    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;
+    }
+
+    /* Операция левого вращения */
+    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;
+    }
+
+    /* Выполнить вращение, чтобы снова сбалансировать поддерево */
+    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;
+    }
+
+    /* Рекурсивная вставка узла (вспомогательный метод) */
+    TreeNode *insertHelper(TreeNode *node, int val) {
+        if (node == nullptr)
+            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;
+    }
+
+    /* Рекурсивное удаление узла (вспомогательный метод) */
+    TreeNode *removeHelper(TreeNode *node, int val) {
+        if (node == nullptr)
+            return nullptr;
+        /* 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 == nullptr || node->right == nullptr) {
+                TreeNode *child = node->left != nullptr ? node->left : node->right;
+                // Число дочерних узлов = 0, удалить node и сразу вернуть
+                if (child == nullptr) {
+                    delete node;
+                    return nullptr;
+                }
+                // Число дочерних узлов = 1, удалить node напрямую
+                else {
+                    delete node;
+                    node = child;
+                }
+            } else {
+                // Число дочерних узлов = 2, удалить следующий по симметричному обходу узел и заменить им текущий узел
+                TreeNode *temp = node->right;
+                while (temp->left != nullptr) {
+                    temp = temp->left;
+                }
+                int tempVal = temp->val;
+                node->right = removeHelper(node->right, temp->val);
+                node->val = tempVal;
+            }
+        }
+        updateHeight(node); // Обновить высоту узла
+        /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */
+        node = rotate(node);
+        // Вернуть корневой узел поддерева
+        return node;
+    }
+
+  public:
+    TreeNode *root; // Корневой узел
+
+    /* Получить высоту узла */
+    int height(TreeNode *node) {
+        // Высота пустого узла равна -1, высота листового узла равна 0
+        return node == nullptr ? -1 : node->height;
+    }
+
+    /* Получить коэффициент баланса */
+    int balanceFactor(TreeNode *node) {
+        // Коэффициент баланса пустого узла равен 0
+        if (node == nullptr)
+            return 0;
+        // Коэффициент баланса узла = высота левого поддерева - высота правого поддерева
+        return height(node->left) - height(node->right);
+    }
+
+    /* Вставка узла */
+    void insert(int val) {
+        root = insertHelper(root, val);
+    }
+
+    /* Удаление узла */
+    void remove(int val) {
+        root = removeHelper(root, val);
+    }
+
+    /* Поиск узла */
+    TreeNode *search(int val) {
+        TreeNode *cur = root;
+        // Искать в цикле и выйти после прохода за листовой узел
+        while (cur != nullptr) {
+            // Целевой узел находится в правом поддереве cur
+            if (cur->val < val)
+                cur = cur->right;
+            // Целевой узел находится в левом поддереве cur
+            else if (cur->val > val)
+                cur = cur->left;
+            // Найти целевой узел и выйти из цикла
+            else
+                break;
+        }
+        // Вернуть целевой узел
+        return cur;
+    }
+
+    /* Конструктор */
+    AVLTree() : root(nullptr) {
+    }
+
+    /* Метод-деструктор */
+    ~AVLTree() {
+        freeMemoryTree(root);
+    }
+};
+
+void testInsert(AVLTree &tree, int val) {
+    tree.insert(val);
+    cout << "\nПосле вставки узла " << val << " AVL-дерево имеет вид" << endl;
+    printTree(tree.root);
+}
+
+void testRemove(AVLTree &tree, int val) {
+    tree.remove(val);
+    cout << "\nПосле удаления узла " << val << " AVL-дерево имеет вид" << endl;
+    printTree(tree.root);
+}
+
+/* Driver Code */
+int main() {
+    /* Инициализация пустого AVL-дерева */
+    AVLTree 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);
+    cout << "\nНайденный объект узла = " << node << ", значение узла = " << node->val << endl;
+}

ru/codes/cpp/chapter_tree/binary_search_tree.cpp

@@ -0,0 +1,170 @@
+/**
+ * File: binary_search_tree.cpp
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Двоичное дерево поиска */
+class BinarySearchTree {
+  private:
+    TreeNode *root;
+
+  public:
+    /* Конструктор */
+    BinarySearchTree() {
+        // Инициализировать пустое дерево
+        root = nullptr;
+    }
+
+    /* Метод-деструктор */
+    ~BinarySearchTree() {
+        freeMemoryTree(root);
+    }
+
+    /* Получить корневой узел двоичного дерева */
+    TreeNode *getRoot() {
+        return root;
+    }
+
+    /* Поиск узла */
+    TreeNode *search(int num) {
+        TreeNode *cur = root;
+        // Искать в цикле и выйти после прохода за листовой узел
+        while (cur != nullptr) {
+            // Целевой узел находится в правом поддереве cur
+            if (cur->val < num)
+                cur = cur->right;
+            // Целевой узел находится в левом поддереве cur
+            else if (cur->val > num)
+                cur = cur->left;
+            // Найти целевой узел и выйти из цикла
+            else
+                break;
+        }
+        // Вернуть целевой узел
+        return cur;
+    }
+
+    /* Вставка узла */
+    void insert(int num) {
+        // Если дерево пусто, инициализировать корневой узел
+        if (root == nullptr) {
+            root = new TreeNode(num);
+            return;
+        }
+        TreeNode *cur = root, *pre = nullptr;
+        // Искать в цикле и выйти после прохода за листовой узел
+        while (cur != nullptr) {
+            // Найти повторяющийся узел и сразу вернуть
+            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;
+    }
+
+    /* Удаление узла */
+    void remove(int num) {
+        // Если дерево пусто, сразу вернуть
+        if (root == nullptr)
+            return;
+        TreeNode *cur = root, *pre = nullptr;
+        // Искать в цикле и выйти после прохода за листовой узел
+        while (cur != nullptr) {
+            // Найти узел для удаления и выйти из цикла
+            if (cur->val == num)
+                break;
+            pre = cur;
+            // Узел для удаления находится в правом поддереве cur
+            if (cur->val < num)
+                cur = cur->right;
+            // Узел для удаления находится в левом поддереве cur
+            else
+                cur = cur->left;
+        }
+        // Если узел для удаления отсутствует, сразу вернуть
+        if (cur == nullptr)
+            return;
+        // Число дочерних узлов = 0 или 1
+        if (cur->left == nullptr || cur->right == nullptr) {
+            // Когда число дочерних узлов = 0 / 1, child = nullptr / этот дочерний узел
+            TreeNode *child = cur->left != nullptr ? cur->left : cur->right;
+            // Удалить узел cur
+            if (cur != root) {
+                if (pre->left == cur)
+                    pre->left = child;
+                else
+                    pre->right = child;
+            } else {
+                // Если удаляемый узел является корнем, заново назначить корневой узел
+                root = child;
+            }
+            // Освободить память
+            delete cur;
+        }
+        // Число дочерних узлов = 2
+        else {
+            // Получить следующий узел после cur в симметричном обходе
+            TreeNode *tmp = cur->right;
+            while (tmp->left != nullptr) {
+                tmp = tmp->left;
+            }
+            int tmpVal = tmp->val;
+            // Рекурсивно удалить узел tmp
+            remove(tmp->val);
+            // Перезаписать cur значением tmp
+            cur->val = tmpVal;
+        }
+    }
+};
+
+/* Driver Code */
+int main() {
+    /* Инициализация двоичного дерева поиска */
+    BinarySearchTree *bst = new BinarySearchTree();
+    // Обратите внимание: разные порядки вставки порождают разные двоичные деревья; данная последовательность может построить совершенное двоичное дерево
+    vector<int> nums = {8, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13, 15};
+    for (int num : nums) {
+        bst->insert(num);
+    }
+    cout << endl << "Исходное двоичное дерево\n" << endl;
+    printTree(bst->getRoot());
+
+    /* Поиск узла */
+    TreeNode *node = bst->search(7);
+    cout << endl << "Найденный объект узла = " << node << ", значение узла = " << node->val << endl;
+
+    /* Вставка узла */
+    bst->insert(16);
+    cout << endl << "После вставки узла 16 двоичное дерево имеет вид\n" << endl;
+    printTree(bst->getRoot());
+
+    /* Удаление узла */
+    bst->remove(1);
+    cout << endl << "После удаления узла 1 двоичное дерево имеет вид\n" << endl;
+    printTree(bst->getRoot());
+    bst->remove(2);
+    cout << endl << "После удаления узла 2 двоичное дерево имеет вид\n" << endl;
+    printTree(bst->getRoot());
+    bst->remove(4);
+    cout << endl << "После удаления узла 4 двоичное дерево имеет вид\n" << endl;
+    printTree(bst->getRoot());
+
+    // Освободить память
+    delete bst;
+
+    return 0;
+}

ru/codes/cpp/chapter_tree/binary_tree.cpp

@@ -0,0 +1,43 @@
+/**
+ * File: binary_tree.cpp
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Driver Code */
+int main() {
+    /* Инициализация двоичного дерева */
+    // Инициализация узла
+    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;
+    cout << endl << "Инициализация двоичного дерева\n" << endl;
+    printTree(n1);
+
+    /* Вставка и удаление узлов */
+    TreeNode *P = new TreeNode(0);
+    // Вставить узел P между n1 -> n2
+    n1->left = P;
+    P->left = n2;
+    cout << endl << "После вставки узла P\n" << endl;
+    printTree(n1);
+    // Удалить узел P
+    n1->left = n2;
+    delete P; // Освободить память
+    cout << endl << "После удаления узла P\n" << endl;
+    printTree(n1);
+
+    // Освободить память
+    freeMemoryTree(n1);
+
+    return 0;
+}

ru/codes/cpp/chapter_tree/binary_tree_bfs.cpp

@@ -0,0 +1,42 @@
+/**
+ * File: binary_tree_bfs.cpp
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Обход в ширину */
+vector<int> levelOrder(TreeNode *root) {
+    // Инициализировать очередь и добавить корневой узел
+    queue<TreeNode *> queue;
+    queue.push(root);
+    // Инициализировать список для хранения последовательности обхода
+    vector<int> vec;
+    while (!queue.empty()) {
+        TreeNode *node = queue.front();
+        queue.pop();              // Извлечение из очереди
+        vec.push_back(node->val); // Сохранить значение узла
+        if (node->left != nullptr)
+            queue.push(node->left); // Поместить левый дочерний узел в очередь
+        if (node->right != nullptr)
+            queue.push(node->right); // Поместить правый дочерний узел в очередь
+    }
+    return vec;
+}
+
+/* Driver Code */
+int main() {
+    /* Инициализация двоичного дерева */
+    // Здесь используется функция, напрямую строящая двоичное дерево из массива
+    TreeNode *root = vectorToTree(vector<int>{1, 2, 3, 4, 5, 6, 7});
+    cout << endl << "Инициализация двоичного дерева\n" << endl;
+    printTree(root);
+
+    /* Обход в ширину */
+    vector<int> vec = levelOrder(root);
+    cout << endl << "Последовательность печати узлов при обходе в ширину = ";
+    printVector(vec);
+
+    return 0;
+}

ru/codes/cpp/chapter_tree/binary_tree_dfs.cpp

@@ -0,0 +1,69 @@
+/**
+ * File: binary_tree_dfs.cpp
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+// Инициализировать список для хранения последовательности обхода
+vector<int> vec;
+
+/* Предварительный обход */
+void preOrder(TreeNode *root) {
+    if (root == nullptr)
+        return;
+    // Порядок обхода: корень -> левое поддерево -> правое поддерево
+    vec.push_back(root->val);
+    preOrder(root->left);
+    preOrder(root->right);
+}
+
+/* Симметричный обход */
+void inOrder(TreeNode *root) {
+    if (root == nullptr)
+        return;
+    // Порядок обхода: левое поддерево -> корень -> правое поддерево
+    inOrder(root->left);
+    vec.push_back(root->val);
+    inOrder(root->right);
+}
+
+/* Обратный обход */
+void postOrder(TreeNode *root) {
+    if (root == nullptr)
+        return;
+    // Порядок обхода: левое поддерево -> правое поддерево -> корень
+    postOrder(root->left);
+    postOrder(root->right);
+    vec.push_back(root->val);
+}
+
+/* Driver Code */
+int main() {
+    /* Инициализация двоичного дерева */
+    // Здесь используется функция, напрямую строящая двоичное дерево из массива
+    TreeNode *root = vectorToTree(vector<int>{1, 2, 3, 4, 5, 6, 7});
+    cout << endl << "Инициализация двоичного дерева\n" << endl;
+    printTree(root);
+
+    /* Предварительный обход */
+    vec.clear();
+    preOrder(root);
+    cout << endl << "Последовательность печати узлов при предварительном обходе = ";
+    printVector(vec);
+
+    /* Симметричный обход */
+    vec.clear();
+    inOrder(root);
+    cout << endl << "Последовательность печати узлов при симметричном обходе = ";
+    printVector(vec);
+
+    /* Обратный обход */
+    vec.clear();
+    postOrder(root);
+    cout << endl << "Последовательность печати узлов при обратном обходе = ";
+    printVector(vec);
+
+    return 0;
+}

ru/codes/cpp/utils/CMakeLists.txt

@@ -0,0 +1,4 @@
+add_executable(utils
+        common.hpp print_utils.hpp
+        list_node.hpp tree_node.hpp
+        vertex.hpp)

ru/codes/cpp/utils/common.hpp

@@ -0,0 +1,28 @@
+/**
+ * File: common.hpp
+ * Created Time: 2021-12-19
+ * Author: krahets (krahets@163.com)
+ */
+
+#pragma once
+
+#include <algorithm>
+#include <chrono>
+#include <deque>
+#include <iostream>
+#include <list>
+#include <queue>
+#include <random>
+#include <set>
+#include <stack>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include "list_node.hpp"
+#include "print_utils.hpp"
+#include "tree_node.hpp"
+#include "vertex.hpp"
+
+using namespace std;