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/javascript/.prettierrc

@@ -0,0 +1,6 @@
+{
+    "tabWidth": 4,
+    "useTabs": false,
+    "semi": true,
+    "singleQuote": true
+}

ru/codes/javascript/chapter_array_and_linkedlist/array.js

@@ -0,0 +1,97 @@
+/**
+ * File: array.js
+ * Created Time: 2022-11-27
+ * Author: IsChristina (christinaxia77@foxmail.com)
+ */
+
+/* Случайный доступ к элементу */
+function randomAccess(nums) {
+    // Случайным образом выбрать число из интервала [0, nums.length)
+    const random_index = Math.floor(Math.random() * nums.length);
+    // Получить и вернуть случайный элемент
+    const random_num = nums[random_index];
+    return random_num;
+}
+
+/* Увеличить длину массива */
+// Обратите внимание: Array в JavaScript — это динамический массив, его можно расширять напрямую
+// Для удобства обучения в этой функции Array рассматривается как массив неизменяемой длины
+function extend(nums, enlarge) {
+    // Инициализировать массив увеличенной длины
+    const res = new Array(nums.length + enlarge).fill(0);
+    // Скопировать все элементы исходного массива в новый массив
+    for (let i = 0; i < nums.length; i++) {
+        res[i] = nums[i];
+    }
+    // Вернуть новый массив после расширения
+    return res;
+}
+
+/* Вставить элемент num по индексу index в массив */
+function insert(nums, num, index) {
+    // Сдвинуть элемент с индексом index и все последующие элементы на одну позицию назад
+    for (let i = nums.length - 1; i > index; i--) {
+        nums[i] = nums[i - 1];
+    }
+    // Присвоить num элементу по индексу index
+    nums[index] = num;
+}
+
+/* Удалить элемент по индексу index */
+function remove(nums, index) {
+    // Сдвинуть все элементы после индекса index на одну позицию вперед
+    for (let i = index; i < nums.length - 1; i++) {
+        nums[i] = nums[i + 1];
+    }
+}
+
+/* Обход массива */
+function traverse(nums) {
+    let count = 0;
+    // Обход массива по индексам
+    for (let i = 0; i < nums.length; i++) {
+        count += nums[i];
+    }
+    // Непосредственно обходить элементы массива
+    for (const num of nums) {
+        count += num;
+    }
+}
+
+/* Найти заданный элемент в массиве */
+function find(nums, target) {
+    for (let i = 0; i < nums.length; i++) {
+        if (nums[i] === target) return i;
+    }
+    return -1;
+}
+
+/* Driver Code */
+/* Инициализация массива */
+const arr = new Array(5).fill(0);
+console.log('Массив arr =', arr);
+let nums = [1, 3, 2, 5, 4];
+console.log('Массив nums =', nums);
+
+/* Случайный доступ */
+let random_num = randomAccess(nums);
+console.log('Случайный элемент из nums =', random_num);
+
+/* Расширение длины */
+nums = extend(nums, 3);
+console.log('После увеличения длины массива до 8 nums =', nums);
+
+/* Вставка элемента */
+insert(nums, 6, 3);
+console.log('После вставки числа 6 по индексу 3 nums =', nums);
+
+/* Удаление элемента */
+remove(nums, 2);
+console.log('После удаления элемента по индексу 2 nums =', nums);
+
+/* Обход массива */
+traverse(nums);
+
+/* Поиск элемента */
+let index = find(nums, 3);
+console.log('Поиск элемента 3 в nums: индекс =', index);

ru/codes/javascript/chapter_array_and_linkedlist/linked_list.js

@@ -0,0 +1,82 @@
+/**
+ * File: linked_list.js
+ * Created Time: 2022-12-12
+ * Author: IsChristina (christinaxia77@foxmail.com), Justin (xiefahit@gmail.com)
+ */
+
+const { printLinkedList } = require('../modules/PrintUtil');
+const { ListNode } = require('../modules/ListNode');
+
+/* Вставить узел P после узла n0 в связном списке */
+function insert(n0, P) {
+    const n1 = n0.next;
+    P.next = n1;
+    n0.next = P;
+}
+
+/* Удалить первый узел после узла n0 в связном списке */
+function remove(n0) {
+    if (!n0.next) return;
+    // n0 -> P -> n1
+    const P = n0.next;
+    const n1 = P.next;
+    n0.next = n1;
+}
+
+/* Доступ к узлу связного списка по индексу index */
+function access(head, index) {
+    for (let i = 0; i < index; i++) {
+        if (!head) {
+            return null;
+        }
+        head = head.next;
+    }
+    return head;
+}
+
+/* Найти в связном списке первый узел со значением target */
+function find(head, target) {
+    let index = 0;
+    while (head !== null) {
+        if (head.val === target) {
+            return index;
+        }
+        head = head.next;
+        index += 1;
+    }
+    return -1;
+}
+
+/* Driver Code */
+/* Инициализация связного списка */
+// Инициализация всех узлов
+const n0 = new ListNode(1);
+const n1 = new ListNode(3);
+const n2 = new ListNode(2);
+const n3 = new ListNode(5);
+const n4 = new ListNode(4);
+// Построить ссылки между узлами
+n0.next = n1;
+n1.next = n2;
+n2.next = n3;
+n3.next = n4;
+console.log('Исходный связный список');
+printLinkedList(n0);
+
+/* Вставка узла */
+insert(n0, new ListNode(0));
+console.log('Связный список после вставки узла');
+printLinkedList(n0);
+
+/* Удаление узла */
+remove(n0);
+console.log('Связный список после удаления узла');
+printLinkedList(n0);
+
+/* Доступ к узлу */
+const node = access(n0, 3);
+console.log('Значение узла по индексу 3 в связном списке = ' + node.val);
+
+/* Поиск узла */
+const index = find(n0, 2);
+console.log('Индекс узла со значением 2 в связном списке = ' + index);

ru/codes/javascript/chapter_array_and_linkedlist/list.js

@@ -0,0 +1,57 @@
+/**
+ * File: list.js
+ * Created Time: 2022-12-12
+ * Author: Justin (xiefahit@gmail.com)
+ */
+
+/* Инициализация списка */
+const nums = [1, 3, 2, 5, 4];
+console.log(`Список nums = ${nums}`);
+
+/* Доступ к элементу */
+const num = nums[1];
+console.log(`Элемент по индексу 1: num = ${num}`);
+
+/* Обновление элемента */
+nums[1] = 0;
+console.log(`После обновления элемента по индексу 1 до 0 nums = ${nums}`);
+
+/* Очистить список */
+nums.length = 0;
+console.log(`После очистки списка nums = ${nums}`);
+
+/* Добавление элемента в конец */
+nums.push(1);
+nums.push(3);
+nums.push(2);
+nums.push(5);
+nums.push(4);
+console.log(`После добавления элементов nums = ${nums}`);
+
+/* Вставка элемента в середину */
+nums.splice(3, 0, 6);
+console.log(`После вставки числа 6 по индексу 3 nums = ${nums}`);
+
+/* Удаление элемента */
+nums.splice(3, 1);
+console.log(`После удаления элемента по индексу 3 nums = ${nums}`);
+
+/* Обходить список по индексам */
+let count = 0;
+for (let i = 0; i < nums.length; i++) {
+    count += nums[i];
+}
+/* Непосредственно обходить элементы списка */
+count = 0;
+for (const x of nums) {
+    count += x;
+}
+
+/* Объединить два списка */
+const nums1 = [6, 8, 7, 10, 9];
+nums.push(...nums1);
+console.log(`После конкатенации списка nums1 к nums nums = ${nums}`);
+
+/* Отсортировать список */
+nums.sort((a, b) => a - b);
+console.log(`После сортировки списка nums = ${nums}`);

ru/codes/javascript/chapter_array_and_linkedlist/my_list.js

@@ -0,0 +1,141 @@
+/**
+ * File: my_list.js
+ * Created Time: 2022-12-12
+ * Author: Justin (xiefahit@gmail.com)
+ */
+
+/* Класс списка */
+class MyList {
+    #arr = new Array(); // Массив (для хранения элементов списка)
+    #capacity = 10; // Вместимость списка
+    #size = 0; // Длина списка (текущее число элементов)
+    #extendRatio = 2; // Коэффициент увеличения списка при каждом расширении
+
+    /* Конструктор */
+    constructor() {
+        this.#arr = new Array(this.#capacity);
+    }
+
+    /* Получить длину списка (текущее число элементов) */
+    size() {
+        return this.#size;
+    }
+
+    /* Получить вместимость списка */
+    capacity() {
+        return this.#capacity;
+    }
+
+    /* Доступ к элементу */
+    get(index) {
+        // Если индекс выходит за границы, выбрасывается исключение; далее аналогично
+        if (index < 0 || index >= this.#size) throw new Error('индекс выходит за границы');
+        return this.#arr[index];
+    }
+
+    /* Обновление элемента */
+    set(index, num) {
+        if (index < 0 || index >= this.#size) throw new Error('индекс выходит за границы');
+        this.#arr[index] = num;
+    }
+
+    /* Добавление элемента в конец */
+    add(num) {
+        // Если длина равна вместимости, требуется расширение
+        if (this.#size === this.#capacity) {
+            this.extendCapacity();
+        }
+        // Добавить новый элемент в конец списка
+        this.#arr[this.#size] = num;
+        this.#size++;
+    }
+
+    /* Вставка элемента в середину */
+    insert(index, num) {
+        if (index < 0 || index >= this.#size) throw new Error('индекс выходит за границы');
+        // При превышении вместимости по числу элементов запускается расширение
+        if (this.#size === this.#capacity) {
+            this.extendCapacity();
+        }
+        // Сдвинуть элемент с индексом index и все следующие элементы на одну позицию назад
+        for (let j = this.#size - 1; j >= index; j--) {
+            this.#arr[j + 1] = this.#arr[j];
+        }
+        // Обновить число элементов
+        this.#arr[index] = num;
+        this.#size++;
+    }
+
+    /* Удаление элемента */
+    remove(index) {
+        if (index < 0 || index >= this.#size) throw new Error('индекс выходит за границы');
+        let num = this.#arr[index];
+        // Сдвинуть все элементы после индекса index на одну позицию вперед
+        for (let j = index; j < this.#size - 1; j++) {
+            this.#arr[j] = this.#arr[j + 1];
+        }
+        // Обновить число элементов
+        this.#size--;
+        // Вернуть удаленный элемент
+        return num;
+    }
+
+    /* Расширение списка */
+    extendCapacity() {
+        // Создать новый массив длиной в extendRatio раз больше исходного и скопировать в него исходный массив
+        this.#arr = this.#arr.concat(
+            new Array(this.capacity() * (this.#extendRatio - 1))
+        );
+        // Обновить вместимость списка
+        this.#capacity = this.#arr.length;
+    }
+
+    /* Преобразовать список в массив */
+    toArray() {
+        let size = this.size();
+        // Преобразовывать только элементы списка в пределах фактической длины
+        const arr = new Array(size);
+        for (let i = 0; i < size; i++) {
+            arr[i] = this.get(i);
+        }
+        return arr;
+    }
+}
+
+/* Driver Code */
+/* Инициализация списка */
+const nums = new MyList();
+/* Добавление элемента в конец */
+nums.add(1);
+nums.add(3);
+nums.add(2);
+nums.add(5);
+nums.add(4);
+console.log(
+    `Список nums = ${nums.toArray()}, вместимость = ${nums.capacity()}, длина = ${nums.size()}`
+);
+
+/* Вставка элемента в середину */
+nums.insert(3, 6);
+console.log(`После вставки числа 6 по индексу 3 nums = ${nums.toArray()}`);
+
+/* Удаление элемента */
+nums.remove(3);
+console.log(`После удаления элемента по индексу 3 nums = ${nums.toArray()}`);
+
+/* Доступ к элементу */
+const num = nums.get(1);
+console.log(`Элемент по индексу 1: num = ${num}`);
+
+/* Обновление элемента */
+nums.set(1, 0);
+console.log(`После обновления элемента по индексу 1 до 0 nums = ${nums.toArray()}`);
+
+/* Проверка механизма расширения */
+for (let i = 0; i < 10; i++) {
+    // При i = 5 длина списка превысит его вместимость, и в этот момент сработает механизм расширения
+    nums.add(i);
+}
+console.log(
+    `Список nums после увеличения вместимости = ${nums.toArray()}, вместимость = ${nums.capacity()}, длина = ${nums.size()}`
+);

ru/codes/javascript/chapter_backtracking/n_queens.js

@@ -0,0 +1,55 @@
+/**
+ * File: n_queens.js
+ * Created Time: 2023-05-13
+ * Author: Justin (xiefahit@gmail.com)
+ */
+
+/* Алгоритм бэктрекинга: n ферзей */
+function backtrack(row, n, state, res, cols, diags1, diags2) {
+    // Когда все строки уже обработаны, записать решение
+    if (row === n) {
+        res.push(state.map((row) => row.slice()));
+        return;
+    }
+    // Обойти все столбцы
+    for (let col = 0; col < n; col++) {
+        // Вычислить главную и побочную диагонали, соответствующие этой клетке
+        const diag1 = row - col + n - 1;
+        const 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 ферзях */
+function nQueens(n) {
+    // Инициализировать доску размера n*n, где 'Q' обозначает ферзя, а '#' — пустую клетку
+    const state = Array.from({ length: n }, () => Array(n).fill('#'));
+    const cols = Array(n).fill(false); // Отмечать, есть ли ферзь в столбце
+    const diags1 = Array(2 * n - 1).fill(false); // Отмечать наличие ферзя на главной диагонали
+    const diags2 = Array(2 * n - 1).fill(false); // Отмечать наличие ферзя на побочной диагонали
+    const res = [];
+
+    backtrack(0, n, state, res, cols, diags1, diags2);
+    return res;
+}
+
+// Driver Code
+const n = 4;
+const res = nQueens(n);
+
+console.log(`Размер входной доски = ${n}`);
+console.log(`Количество способов расстановки ферзей: ${res.length}`);
+res.forEach((state) => {
+    console.log('--------------------');
+    state.forEach((row) => console.log(row));
+});

ru/codes/javascript/chapter_backtracking/permutations_i.js

@@ -0,0 +1,42 @@
+/**
+ * File: permutations_i.js
+ * Created Time: 2023-05-13
+ * Author: Justin (xiefahit@gmail.com)
+ */
+
+/* Алгоритм бэктрекинга: все перестановки I */
+function backtrack(state, choices, selected, res) {
+    // Когда длина состояния равна числу элементов, записать решение
+    if (state.length === choices.length) {
+        res.push([...state]);
+        return;
+    }
+    // Перебор всех вариантов выбора
+    choices.forEach((choice, i) => {
+        // Отсечение: нельзя выбирать один и тот же элемент повторно
+        if (!selected[i]) {
+            // Попытка: сделать выбор и обновить состояние
+            selected[i] = true;
+            state.push(choice);
+            // Перейти к следующему выбору
+            backtrack(state, choices, selected, res);
+            // Откат: отменить выбор и восстановить предыдущее состояние
+            selected[i] = false;
+            state.pop();
+        }
+    });
+}
+
+/* Все перестановки I */
+function permutationsI(nums) {
+    const res = [];
+    backtrack([], nums, Array(nums.length).fill(false), res);
+    return res;
+}
+
+// Driver Code
+const nums = [1, 2, 3];
+const res = permutationsI(nums);
+
+console.log(`Входной массив nums = ${JSON.stringify(nums)}`);
+console.log(`Все перестановки res = ${JSON.stringify(res)}`);

ru/codes/javascript/chapter_backtracking/permutations_ii.js

@@ -0,0 +1,44 @@
+/**
+ * File: permutations_ii.js
+ * Created Time: 2023-05-13
+ * Author: Justin (xiefahit@gmail.com)
+ */
+
+/* Алгоритм бэктрекинга: все перестановки II */
+function backtrack(state, choices, selected, res) {
+    // Когда длина состояния равна числу элементов, записать решение
+    if (state.length === choices.length) {
+        res.push([...state]);
+        return;
+    }
+    // Перебор всех вариантов выбора
+    const duplicated = new Set();
+    choices.forEach((choice, i) => {
+        // Отсечение: нельзя выбирать один и тот же элемент повторно и нельзя повторно выбирать равные элементы
+        if (!selected[i] && !duplicated.has(choice)) {
+            // Попытка: сделать выбор и обновить состояние
+            duplicated.add(choice); // Записать значения уже выбранных элементов
+            selected[i] = true;
+            state.push(choice);
+            // Перейти к следующему выбору
+            backtrack(state, choices, selected, res);
+            // Откат: отменить выбор и восстановить предыдущее состояние
+            selected[i] = false;
+            state.pop();
+        }
+    });
+}
+
+/* Все перестановки II */
+function permutationsII(nums) {
+    const res = [];
+    backtrack([], nums, Array(nums.length).fill(false), res);
+    return res;
+}
+
+// Driver Code
+const nums = [1, 2, 2];
+const res = permutationsII(nums);
+
+console.log(`Входной массив nums = ${JSON.stringify(nums)}`);
+console.log(`Все перестановки res = ${JSON.stringify(res)}`);

ru/codes/javascript/chapter_backtracking/preorder_traversal_i_compact.js

@@ -0,0 +1,33 @@
+/**
+ * File: preorder_traversal_i_compact.js
+ * Created Time: 2023-05-09
+ * Author: Justin (xiefahit@gmail.com)
+ */
+
+const { arrToTree } = require('../modules/TreeNode');
+const { printTree } = require('../modules/PrintUtil');
+
+/* Предварительный обход: пример 1 */
+function preOrder(root, res) {
+    if (root === null) {
+        return;
+    }
+    if (root.val === 7) {
+        // Записать решение
+        res.push(root);
+    }
+    preOrder(root.left, res);
+    preOrder(root.right, res);
+}
+
+// Driver Code
+const root = arrToTree([1, 7, 3, 4, 5, 6, 7]);
+console.log('\nИнициализация двоичного дерева');
+printTree(root);
+
+// Предварительный обход
+const res = [];
+preOrder(root, res);
+
+console.log('\nВсе узлы со значением 7');
+console.log(res.map((node) => node.val));

ru/codes/javascript/chapter_backtracking/preorder_traversal_ii_compact.js

@@ -0,0 +1,40 @@
+/**
+ * File: preorder_traversal_ii_compact.js
+ * Created Time: 2023-05-09
+ * Author: Justin (xiefahit@gmail.com)
+ */
+
+const { arrToTree } = require('../modules/TreeNode');
+const { printTree } = require('../modules/PrintUtil');
+
+/* Предварительный обход: пример 2 */
+function preOrder(root, path, res) {
+    if (root === null) {
+        return;
+    }
+    // Попытка
+    path.push(root);
+    if (root.val === 7) {
+        // Записать решение
+        res.push([...path]);
+    }
+    preOrder(root.left, path, res);
+    preOrder(root.right, path, res);
+    // Откат
+    path.pop();
+}
+
+// Driver Code
+const root = arrToTree([1, 7, 3, 4, 5, 6, 7]);
+console.log('\nИнициализация двоичного дерева');
+printTree(root);
+
+// Предварительный обход
+const path = [];
+const res = [];
+preOrder(root, path, res);
+
+console.log('\nВсе пути от корня к узлу 7');
+res.forEach((path) => {
+    console.log(path.map((node) => node.val));
+});

ru/codes/javascript/chapter_backtracking/preorder_traversal_iii_compact.js

@@ -0,0 +1,41 @@
+/**
+ * File: preorder_traversal_iii_compact.js
+ * Created Time: 2023-05-09
+ * Author: Justin (xiefahit@gmail.com)
+ */
+
+const { arrToTree } = require('../modules/TreeNode');
+const { printTree } = require('../modules/PrintUtil');
+
+/* Предварительный обход: пример 3 */
+function preOrder(root, path, res) {
+    // Отсечение
+    if (root === null || root.val === 3) {
+        return;
+    }
+    // Попытка
+    path.push(root);
+    if (root.val === 7) {
+        // Записать решение
+        res.push([...path]);
+    }
+    preOrder(root.left, path, res);
+    preOrder(root.right, path, res);
+    // Откат
+    path.pop();
+}
+
+// Driver Code
+const root = arrToTree([1, 7, 3, 4, 5, 6, 7]);
+console.log('\nИнициализация двоичного дерева');
+printTree(root);
+
+// Предварительный обход
+const path = [];
+const res = [];
+preOrder(root, path, res);
+
+console.log('\nВсе пути от корня к узлу 7, не содержащие узлов со значением 3');
+res.forEach((path) => {
+    console.log(path.map((node) => node.val));
+});

ru/codes/javascript/chapter_backtracking/preorder_traversal_iii_template.js

@@ -0,0 +1,68 @@
+/**
+ * File: preorder_traversal_iii_template.js
+ * Created Time: 2023-05-09
+ * Author: Justin (xiefahit@gmail.com)
+ */
+
+const { arrToTree } = require('../modules/TreeNode');
+const { printTree } = require('../modules/PrintUtil');
+
+/* Проверить, является ли текущее состояние решением */
+function isSolution(state) {
+    return state && state[state.length - 1]?.val === 7;
+}
+
+/* Записать решение */
+function recordSolution(state, res) {
+    res.push([...state]);
+}
+
+/* Проверить, допустим ли этот выбор в текущем состоянии */
+function isValid(state, choice) {
+    return choice !== null && choice.val !== 3;
+}
+
+/* Обновить состояние */
+function makeChoice(state, choice) {
+    state.push(choice);
+}
+
+/* Восстановить состояние */
+function undoChoice(state) {
+    state.pop();
+}
+
+/* Алгоритм бэктрекинга: пример 3 */
+function backtrack(state, choices, res) {
+    // Проверить, является ли текущее состояние решением
+    if (isSolution(state)) {
+        // Записать решение
+        recordSolution(state, res);
+    }
+    // Перебор всех вариантов выбора
+    for (const choice of choices) {
+        // Отсечение: проверить допустимость выбора
+        if (isValid(state, choice)) {
+            // Попытка: сделать выбор и обновить состояние
+            makeChoice(state, choice);
+            // Перейти к следующему выбору
+            backtrack(state, [choice.left, choice.right], res);
+            // Откат: отменить выбор и восстановить предыдущее состояние
+            undoChoice(state);
+        }
+    }
+}
+
+// Driver Code
+const root = arrToTree([1, 7, 3, 4, 5, 6, 7]);
+console.log('\nИнициализация двоичного дерева');
+printTree(root);
+
+// Алгоритм бэктрекинга
+const res = [];
+backtrack([], [root], res);
+
+console.log('\nВсе пути от корня к узлу 7, в которых путь не содержит узлов со значением 3');
+res.forEach((path) => {
+    console.log(path.map((node) => node.val));
+});

ru/codes/javascript/chapter_backtracking/subset_sum_i.js

@@ -0,0 +1,46 @@
+/**
+ * File: subset_sum_i.js
+ * Created Time: 2023-07-30
+ * Author: yuan0221 (yl1452491917@gmail.com)
+ */
+
+/* Алгоритм бэктрекинга: сумма подмножеств I */
+function backtrack(state, target, choices, start, res) {
+    // Если сумма подмножества равна target, записать решение
+    if (target === 0) {
+        res.push([...state]);
+        return;
+    }
+    // Обойти все варианты выбора
+    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств
+    for (let i = start; i < choices.length; i++) {
+        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл
+        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target
+        if (target - choices[i] < 0) {
+            break;
+        }
+        // Попытка: сделать выбор и обновить target и start
+        state.push(choices[i]);
+        // Перейти к следующему выбору
+        backtrack(state, target - choices[i], choices, i, res);
+        // Откат: отменить выбор и восстановить предыдущее состояние
+        state.pop();
+    }
+}
+
+/* Решить задачу суммы подмножеств I */
+function subsetSumI(nums, target) {
+    const state = []; // Состояние (подмножество)
+    nums.sort((a, b) => a - b); // Отсортировать nums
+    const start = 0; // Стартовая вершина обхода
+    const res = []; // Список результатов (список подмножеств)
+    backtrack(state, target, nums, start, res);
+    return res;
+}
+
+/* Driver Code */
+const nums = [3, 4, 5];
+const target = 9;
+const res = subsetSumI(nums, target);
+console.log(`Входной массив nums = ${JSON.stringify(nums)}, target = ${target}`);
+console.log(`Все подмножества с суммой ${target}: res = ${JSON.stringify(res)}`);

ru/codes/javascript/chapter_backtracking/subset_sum_i_naive.js

@@ -0,0 +1,44 @@
+/**
+ * File: subset_sum_i_naive.js
+ * Created Time: 2023-07-30
+ * Author: yuan0221 (yl1452491917@gmail.com)
+ */
+
+/* Алгоритм бэктрекинга: сумма подмножеств I */
+function backtrack(state, target, total, choices, res) {
+    // Если сумма подмножества равна target, записать решение
+    if (total === target) {
+        res.push([...state]);
+        return;
+    }
+    // Перебор всех вариантов выбора
+    for (let i = 0; i < choices.length; i++) {
+        // Отсечение: если сумма подмножества превышает target, пропустить этот выбор
+        if (total + choices[i] > target) {
+            continue;
+        }
+        // Попытка: сделать выбор и обновить элемент и total
+        state.push(choices[i]);
+        // Перейти к следующему выбору
+        backtrack(state, target, total + choices[i], choices, res);
+        // Откат: отменить выбор и восстановить предыдущее состояние
+        state.pop();
+    }
+}
+
+/* Решить задачу суммы подмножеств I (с повторяющимися подмножествами) */
+function subsetSumINaive(nums, target) {
+    const state = []; // Состояние (подмножество)
+    const total = 0; // Сумма подмножеств
+    const res = []; // Список результатов (список подмножеств)
+    backtrack(state, target, total, nums, res);
+    return res;
+}
+
+/* Driver Code */
+const nums = [3, 4, 5];
+const target = 9;
+const res = subsetSumINaive(nums, target);
+console.log(`Входной массив nums = ${JSON.stringify(nums)}, target = ${target}`);
+console.log(`Все подмножества с суммой ${target}: res = ${JSON.stringify(res)}`);
+console.log('Обратите внимание: результат этого метода содержит повторяющиеся множества');

ru/codes/javascript/chapter_backtracking/subset_sum_ii.js

@@ -0,0 +1,51 @@
+/**
+ * File: subset_sum_ii.js
+ * Created Time: 2023-07-30
+ * Author: yuan0221 (yl1452491917@gmail.com)
+ */
+
+/* Алгоритм бэктрекинга: сумма подмножеств II */
+function backtrack(state, target, choices, start, res) {
+    // Если сумма подмножества равна target, записать решение
+    if (target === 0) {
+        res.push([...state]);
+        return;
+    }
+    // Обойти все варианты выбора
+    // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств
+    // Отсечение 3: начинать обход с start, чтобы избежать повторного выбора одного и того же элемента
+    for (let i = start; i < choices.length; i++) {
+        // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл
+        // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target
+        if (target - choices[i] < 0) {
+            break;
+        }
+        // Отсечение 4: если этот элемент равен элементу слева, значит ветвь поиска повторяется, ее нужно сразу пропустить
+        if (i > start && choices[i] === choices[i - 1]) {
+            continue;
+        }
+        // Попытка: сделать выбор и обновить target и start
+        state.push(choices[i]);
+        // Перейти к следующему выбору
+        backtrack(state, target - choices[i], choices, i + 1, res);
+        // Откат: отменить выбор и восстановить предыдущее состояние
+        state.pop();
+    }
+}
+
+/* Решить задачу суммы подмножеств II */
+function subsetSumII(nums, target) {
+    const state = []; // Состояние (подмножество)
+    nums.sort((a, b) => a - b); // Отсортировать nums
+    const start = 0; // Стартовая вершина обхода
+    const res = []; // Список результатов (список подмножеств)
+    backtrack(state, target, nums, start, res);
+    return res;
+}
+
+/* Driver Code */
+const nums = [4, 4, 5];
+const target = 9;
+const res = subsetSumII(nums, target);
+console.log(`Входной массив nums = ${JSON.stringify(nums)}, target = ${target}`);
+console.log(`Все подмножества с суммой ${target}: res = ${JSON.stringify(res)}`);

ru/codes/javascript/chapter_computational_complexity/iteration.js

@@ -0,0 +1,70 @@
+/**
+ * File: iteration.js
+ * Created Time: 2023-08-28
+ * Author: Gaofer Chou (gaofer-chou@qq.com)
+ */
+
+/* Цикл for */
+function forLoop(n) {
+    let res = 0;
+    // Циклическое суммирование 1, 2, ..., n-1, n
+    for (let i = 1; i <= n; i++) {
+        res += i;
+    }
+    return res;
+}
+
+/* Цикл while */
+function whileLoop(n) {
+    let res = 0;
+    let i = 1; // Инициализация условной переменной
+    // Циклическое суммирование 1, 2, ..., n-1, n
+    while (i <= n) {
+        res += i;
+        i++; // Обновить условную переменную
+    }
+    return res;
+}
+
+/* Цикл while (двойное обновление) */
+function whileLoopII(n) {
+    let res = 0;
+    let i = 1; // Инициализация условной переменной
+    // Циклическое суммирование 1, 4, 10, ...
+    while (i <= n) {
+        res += i;
+        // Обновить условную переменную
+        i++;
+        i *= 2;
+    }
+    return res;
+}
+
+/* Двойной цикл for */
+function nestedForLoop(n) {
+    let res = '';
+    // Цикл по i = 1, 2, ..., n-1, n
+    for (let i = 1; i <= n; i++) {
+        // Цикл по j = 1, 2, ..., n-1, n
+        for (let j = 1; j <= n; j++) {
+            res += `(${i}, ${j}), `;
+        }
+    }
+    return res;
+}
+
+/* Driver Code */
+const n = 5;
+let res;
+
+res = forLoop(n);
+console.log(`Результат суммирования в цикле for res = ${res}`);
+
+res = whileLoop(n);
+console.log(`Результат суммирования в цикле while res = ${res}`);
+
+res = whileLoopII(n);
+console.log(`Результат суммирования в цикле while (двойное обновление) res = ${res}`);
+
+const resStr = nestedForLoop(n);
+console.log(`Результат обхода в двойном цикле for ${resStr}`);

ru/codes/javascript/chapter_computational_complexity/recursion.js

@@ -0,0 +1,69 @@
+/**
+ * File: recursion.js
+ * Created Time: 2023-08-28
+ * Author: Gaofer Chou (gaofer-chou@qq.com)
+ */
+
+/* Рекурсия */
+function recur(n) {
+    // Условие завершения
+    if (n === 1) return 1;
+    // Рекурсия: рекурсивный вызов
+    const res = recur(n - 1);
+    // Возврат: вернуть результат
+    return n + res;
+}
+
+/* Имитация рекурсии итерацией */
+function forLoopRecur(n) {
+    // Использовать явный стек для имитации системного стека вызовов
+    const stack = [];
+    let res = 0;
+    // Рекурсия: рекурсивный вызов
+    for (let i = n; i > 0; i--) {
+        // Имитировать «рекурсию» с помощью операции помещения в стек
+        stack.push(i);
+    }
+    // Возврат: вернуть результат
+    while (stack.length) {
+        // Имитировать «возврат» с помощью операции извлечения из стека
+        res += stack.pop();
+    }
+    // res = 1+2+3+...+n
+    return res;
+}
+
+/* Хвостовая рекурсия */
+function tailRecur(n, res) {
+    // Условие завершения
+    if (n === 0) return res;
+    // Хвостовой рекурсивный вызов
+    return tailRecur(n - 1, res + n);
+}
+
+/* Последовательность Фибоначчи: рекурсия */
+function fib(n) {
+    // Условие завершения: f(1) = 0, f(2) = 1
+    if (n === 1 || n === 2) return n - 1;
+    // Рекурсивный вызов f(n) = f(n-1) + f(n-2)
+    const res = fib(n - 1) + fib(n - 2);
+    // Вернуть результат f(n)
+    return res;
+}
+
+/* Driver Code */
+const n = 5;
+let res;
+
+res = recur(n);
+console.log(`Результат суммирования в рекурсивной функции res = ${res}`);
+
+res = forLoopRecur(n);
+console.log(`Результат суммирования при имитации рекурсии итерацией res = ${res}`);
+
+res = tailRecur(n, 0);
+console.log(`Результат суммирования в хвостовой рекурсии res = ${res}`);
+
+res = fib(n);
+console.log(`Член последовательности Фибоначчи с номером ${n} = ${res}`);
+

ru/codes/javascript/chapter_computational_complexity/space_complexity.js

@@ -0,0 +1,103 @@
+/**
+ * File: space_complexity.js
+ * Created Time: 2023-02-05
+ * Author: Justin (xiefahit@gmail.com)
+ */
+
+const { ListNode } = require('../modules/ListNode');
+const { TreeNode } = require('../modules/TreeNode');
+const { printTree } = require('../modules/PrintUtil');
+
+/* Функция */
+function constFunc() {
+    // Выполнить некоторые операции
+    return 0;
+}
+
+/* Постоянная сложность */
+function constant(n) {
+    // Константы, переменные и объекты занимают O(1) памяти
+    const a = 0;
+    const b = 0;
+    const nums = new Array(10000);
+    const node = new ListNode(0);
+    // Переменные в цикле занимают O(1) памяти
+    for (let i = 0; i < n; i++) {
+        const c = 0;
+    }
+    // Функции в цикле занимают O(1) памяти
+    for (let i = 0; i < n; i++) {
+        constFunc();
+    }
+}
+
+/* Линейная сложность */
+function linear(n) {
+    // Массив длины n занимает O(n) памяти
+    const nums = new Array(n);
+    // Список длины n занимает O(n) памяти
+    const nodes = [];
+    for (let i = 0; i < n; i++) {
+        nodes.push(new ListNode(i));
+    }
+    // Хеш-таблица длины n занимает O(n) памяти
+    const map = new Map();
+    for (let i = 0; i < n; i++) {
+        map.set(i, i.toString());
+    }
+}
+
+/* Линейная сложность (рекурсивная реализация) */
+function linearRecur(n) {
+    console.log(`Рекурсия n = ${n}`);
+    if (n === 1) return;
+    linearRecur(n - 1);
+}
+
+/* Квадратичная сложность */
+function quadratic(n) {
+    // Матрица занимает O(n^2) памяти
+    const numMatrix = Array(n)
+        .fill(null)
+        .map(() => Array(n).fill(null));
+    // Двумерный список занимает O(n^2) памяти
+    const numList = [];
+    for (let i = 0; i < n; i++) {
+        const tmp = [];
+        for (let j = 0; j < n; j++) {
+            tmp.push(0);
+        }
+        numList.push(tmp);
+    }
+}
+
+/* Квадратичная сложность (рекурсивная реализация) */
+function quadraticRecur(n) {
+    if (n <= 0) return 0;
+    const nums = new Array(n);
+    console.log(`В рекурсии n = ${n} длина nums = ${nums.length}`);
+    return quadraticRecur(n - 1);
+}
+
+/* Экспоненциальная сложность (построение полного двоичного дерева) */
+function buildTree(n) {
+    if (n === 0) return null;
+    const root = new TreeNode(0);
+    root.left = buildTree(n - 1);
+    root.right = buildTree(n - 1);
+    return root;
+}
+
+/* Driver Code */
+const n = 5;
+// Постоянная сложность
+constant(n);
+// Линейная сложность
+linear(n);
+linearRecur(n);
+// Квадратичная сложность
+quadratic(n);
+quadraticRecur(n);
+// Экспоненциальная сложность
+const root = buildTree(n);
+printTree(root);

ru/codes/javascript/chapter_computational_complexity/time_complexity.js

@@ -0,0 +1,155 @@
+/**
+ * File: time_complexity.js
+ * Created Time: 2023-01-02
+ * Author: RiverTwilight (contact@rene.wang)
+ */
+
+/* Постоянная сложность */
+function constant(n) {
+    let count = 0;
+    const size = 100000;
+    for (let i = 0; i < size; i++) count++;
+    return count;
+}
+
+/* Линейная сложность */
+function linear(n) {
+    let count = 0;
+    for (let i = 0; i < n; i++) count++;
+    return count;
+}
+
+/* Линейная сложность (обход массива) */
+function arrayTraversal(nums) {
+    let count = 0;
+    // Число итераций пропорционально длине массива
+    for (let i = 0; i < nums.length; i++) {
+        count++;
+    }
+    return count;
+}
+
+/* Квадратичная сложность */
+function quadratic(n) {
+    let count = 0;
+    // Число итераций квадратично зависит от размера данных n
+    for (let i = 0; i < n; i++) {
+        for (let j = 0; j < n; j++) {
+            count++;
+        }
+    }
+    return count;
+}
+
+/* Квадратичная сложность (пузырьковая сортировка) */
+function bubbleSort(nums) {
+    let count = 0; // Счетчик
+    // Внешний цикл: неотсортированный диапазон [0, i]
+    for (let i = nums.length - 1; i > 0; i--) {
+        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
+        for (let j = 0; j < i; j++) {
+            if (nums[j] > nums[j + 1]) {
+                // Поменять местами nums[j] и nums[j + 1]
+                let tmp = nums[j];
+                nums[j] = nums[j + 1];
+                nums[j + 1] = tmp;
+                count += 3; // Обмен элементов включает 3 элементарные операции
+            }
+        }
+    }
+    return count;
+}
+
+/* Экспоненциальная сложность (итеративная реализация) */
+function exponential(n) {
+    let count = 0,
+        base = 1;
+    // На каждом шаге клетка делится надвое, образуя последовательность 1, 2, 4, 8, ..., 2^(n-1)
+    for (let i = 0; i < n; i++) {
+        for (let j = 0; j < base; j++) {
+            count++;
+        }
+        base *= 2;
+    }
+    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
+    return count;
+}
+
+/* Экспоненциальная сложность (рекурсивная реализация) */
+function expRecur(n) {
+    if (n === 1) return 1;
+    return expRecur(n - 1) + expRecur(n - 1) + 1;
+}
+
+/* Логарифмическая сложность (итеративная реализация) */
+function logarithmic(n) {
+    let count = 0;
+    while (n > 1) {
+        n = n / 2;
+        count++;
+    }
+    return count;
+}
+
+/* Логарифмическая сложность (рекурсивная реализация) */
+function logRecur(n) {
+    if (n <= 1) return 0;
+    return logRecur(n / 2) + 1;
+}
+
+/* Линейно-логарифмическая сложность */
+function linearLogRecur(n) {
+    if (n <= 1) return 1;
+    let count = linearLogRecur(n / 2) + linearLogRecur(n / 2);
+    for (let i = 0; i < n; i++) {
+        count++;
+    }
+    return count;
+}
+
+/* Факториальная сложность (рекурсивная реализация) */
+function factorialRecur(n) {
+    if (n === 0) return 1;
+    let count = 0;
+    // Из одного получается n
+    for (let i = 0; i < n; i++) {
+        count += factorialRecur(n - 1);
+    }
+    return count;
+}
+
+/* Driver Code */
+// Можно изменить n и запустить программу, чтобы увидеть, как меняется число операций при разных сложностях
+const n = 8;
+console.log('Размер входных данных n = ' + n);
+
+let count = constant(n);
+console.log('Число операций константной сложности = ' + count);
+
+count = linear(n);
+console.log('Число операций линейной сложности = ' + count);
+count = arrayTraversal(new Array(n));
+console.log('Число операций линейной сложности (обход массива) = ' + count);
+
+count = quadratic(n);
+console.log('Число операций квадратичной сложности = ' + count);
+let nums = new Array(n);
+for (let i = 0; i < n; i++) nums[i] = n - i; // [n,n-1,...,2,1]
+count = bubbleSort(nums);
+console.log('Число операций квадратичной сложности (пузырьковая сортировка) = ' + count);
+
+count = exponential(n);
+console.log('Число операций экспоненциальной сложности (итеративная реализация) = ' + count);
+count = expRecur(n);
+console.log('Число операций экспоненциальной сложности (рекурсивная реализация) = ' + count);
+
+count = logarithmic(n);
+console.log('Число операций логарифмической сложности (итеративная реализация) = ' + count);
+count = logRecur(n);
+console.log('Число операций логарифмической сложности (рекурсивная реализация) = ' + count);
+
+count = linearLogRecur(n);
+console.log('Число операций линейно-логарифмической сложности (рекурсивная реализация) = ' + count);
+
+count = factorialRecur(n);
+console.log('Число операций факториальной сложности (рекурсивная реализация) = ' + count);

ru/codes/javascript/chapter_computational_complexity/worst_best_time_complexity.js

@@ -0,0 +1,43 @@
+/**
+ * File: worst_best_time_complexity.js
+ * Created Time: 2023-01-05
+ * Author: RiverTwilight (contact@rene.wang)
+ */
+
+/* Создать массив с элементами { 1, 2, ..., n } в случайном порядке */
+function randomNumbers(n) {
+    const nums = Array(n);
+    // Создать массив nums = { 1, 2, 3, ..., n }
+    for (let i = 0; i < n; i++) {
+        nums[i] = i + 1;
+    }
+    // Случайно перемешать элементы массива
+    for (let i = 0; i < n; i++) {
+        const r = Math.floor(Math.random() * (i + 1));
+        const temp = nums[i];
+        nums[i] = nums[r];
+        nums[r] = temp;
+    }
+    return nums;
+}
+
+/* Найти индекс числа 1 в массиве nums */
+function findOne(nums) {
+    for (let i = 0; i < nums.length; i++) {
+        // Когда элемент 1 находится в начале массива, достигается лучшая временная сложность O(1)
+        // Когда элемент 1 находится в конце массива, достигается худшая временная сложность O(n)
+        if (nums[i] === 1) {
+            return i;
+        }
+    }
+    return -1;
+}
+
+/* Driver Code */
+for (let i = 0; i < 10; i++) {
+    const n = 100;
+    const nums = randomNumbers(n);
+    const index = findOne(nums);
+    console.log('\nМассив [1, 2, ..., n] после перемешивания = [' + nums.join(', ') + ']');
+    console.log('Индекс числа 1 = ' + index);
+}

ru/codes/javascript/chapter_divide_and_conquer/binary_search_recur.js

@@ -0,0 +1,39 @@
+/**
+ * File: binary_search_recur.js
+ * Created Time: 2023-07-30
+ * Author: yuan0221 (yl1452491917@gmail.com)
+ */
+
+/* Бинарный поиск: задача f(i, j) */
+function dfs(nums, target, i, j) {
+    // Если интервал пуст, целевой элемент отсутствует, вернуть -1
+    if (i > j) {
+        return -1;
+    }
+    // Вычислить индекс середины m
+    const m = i + ((j - i) >> 1);
+    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;
+    }
+}
+
+/* Бинарный поиск */
+function binarySearch(nums, target) {
+    const n = nums.length;
+    // Решить задачу f(0, n-1)
+    return dfs(nums, target, 0, n - 1);
+}
+
+/* Driver Code */
+const target = 6;
+const nums = [1, 3, 6, 8, 12, 15, 23, 26, 31, 35];
+// Бинарный поиск (двусторонне замкнутый интервал)
+const index = binarySearch(nums, target);
+console.log(`Индекс целевого элемента 6 = ${index}`);

ru/codes/javascript/chapter_divide_and_conquer/build_tree.js

@@ -0,0 +1,44 @@
+/**
+ * File: build_tree.js
+ * Created Time: 2023-07-30
+ * Author: yuan0221 (yl1452491917@gmail.com)
+ */
+
+const { printTree } = require('../modules/PrintUtil');
+const { TreeNode } = require('../modules/TreeNode');
+
+/* Построить двоичное дерево: разделяй и властвуй */
+function dfs(preorder, inorderMap, i, l, r) {
+    // Завершить при пустом диапазоне поддерева
+    if (r - l < 0) return null;
+    // Инициализировать корневой узел
+    const root = new TreeNode(preorder[i]);
+    // Найти m, чтобы разделить левое и правое поддеревья
+    const m = inorderMap.get(preorder[i]);
+    // Подзадача: построить левое поддерево
+    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);
+    // Подзадача: построить правое поддерево
+    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);
+    // Вернуть корневой узел
+    return root;
+}
+
+/* Построить двоичное дерево */
+function buildTree(preorder, inorder) {
+    // Инициализировать хеш-таблицу для хранения соответствия элементов inorder их индексам
+    let inorderMap = new Map();
+    for (let i = 0; i < inorder.length; i++) {
+        inorderMap.set(inorder[i], i);
+    }
+    const root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);
+    return root;
+}
+
+/* Driver Code */
+const preorder = [3, 9, 2, 1, 7];
+const inorder = [9, 3, 1, 2, 7];
+console.log('Предварительный обход = ' + JSON.stringify(preorder));
+console.log('Симметричный обход = ' + JSON.stringify(inorder));
+const root = buildTree(preorder, inorder);
+console.log('Построенное двоичное дерево:');
+printTree(root);

ru/codes/javascript/chapter_divide_and_conquer/hanota.js

@@ -0,0 +1,52 @@
+/**
+ * File: hanota.js
+ * Created Time: 2023-07-30
+ * Author: yuan0221 (yl1452491917@gmail.com)
+ */
+
+/* Переместить один диск */
+function move(src, tar) {
+    // Снять диск с вершины src
+    const pan = src.pop();
+    // Положить диск на вершину tar
+    tar.push(pan);
+}
+
+/* Решить задачу Ханойской башни f(i) */
+function dfs(i, src, buf, 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);
+}
+
+/* Решить задачу Ханойской башни */
+function solveHanota(A, B, C) {
+    const n = A.length;
+    // Переместить верхние n дисков из A в C с помощью B
+    dfs(n, A, B, C);
+}
+
+/* Driver Code */
+// Хвост списка соответствует вершине столбца
+const A = [5, 4, 3, 2, 1];
+const B = [];
+const C = [];
+console.log('Исходное состояние:');
+console.log(`A = ${JSON.stringify(A)}`);
+console.log(`B = ${JSON.stringify(B)}`);
+console.log(`C = ${JSON.stringify(C)}`);
+
+solveHanota(A, B, C);
+
+console.log('После завершения перемещения дисков:');
+console.log(`A = ${JSON.stringify(A)}`);
+console.log(`B = ${JSON.stringify(B)}`);
+console.log(`C = ${JSON.stringify(C)}`);

ru/codes/javascript/chapter_dynamic_programming/climbing_stairs_backtrack.js

@@ -0,0 +1,34 @@
+/**
+ * File: climbing_stairs_backtrack.js
+ * Created Time: 2023-07-26
+ * Author: yuan0221 (yl1452491917@gmail.com)
+ */
+
+/* Бэктрекинг */
+function backtrack(choices, state, n, res) {
+    // Когда подъем достигает n-й ступени, число вариантов увеличивается на 1
+    if (state === n) res.set(0, res.get(0) + 1);
+    // Перебор всех вариантов выбора
+    for (const choice of choices) {
+        // Отсечение: нельзя выходить за n-ю ступень
+        if (state + choice > n) continue;
+        // Попытка: сделать выбор и обновить состояние
+        backtrack(choices, state + choice, n, res);
+        // Откат
+    }
+}
+
+/* Подъем по лестнице: бэктрекинг */
+function climbingStairsBacktrack(n) {
+    const choices = [1, 2]; // Можно подняться на 1 или 2 ступени
+    const state = 0; // Начать подъем с 0-й ступени
+    const res = new Map();
+    res.set(0, 0); // Использовать res[0] для хранения числа решений
+    backtrack(choices, state, n, res);
+    return res.get(0);
+}
+
+/* Driver Code */
+const n = 9;
+const res = climbingStairsBacktrack(n);
+console.log(`Количество способов подняться по лестнице из ${n} ступеней = ${res}`);

ru/codes/javascript/chapter_dynamic_programming/climbing_stairs_constraint_dp.js

@@ -0,0 +1,30 @@
+/**
+ * File: climbing_stairs_constraint_dp.js
+ * Created Time: 2023-08-23
+ * Author: Gaofer Chou (gaofer-chou@qq.com)
+ */
+
+/* Подъем по лестнице с ограничениями: динамическое программирование */
+function climbingStairsConstraintDP(n) {
+    if (n === 1 || n === 2) {
+        return 1;
+    }
+    // Инициализация таблицы dp для хранения решений подзадач
+    const dp = Array.from(new Array(n + 1), () => new Array(3));
+    // Начальное состояние: заранее задать решения наименьших подзадач
+    dp[1][1] = 1;
+    dp[1][2] = 0;
+    dp[2][1] = 0;
+    dp[2][2] = 1;
+    // Переход состояний: постепенное решение больших подзадач через меньшие
+    for (let 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 */
+const n = 9;
+const res = climbingStairsConstraintDP(n);
+console.log(`Количество способов подняться по лестнице из ${n} ступеней = ${res}`);

ru/codes/javascript/chapter_dynamic_programming/climbing_stairs_dfs.js

@@ -0,0 +1,24 @@
+/**
+ * File: climbing_stairs_dfs.js
+ * Created Time: 2023-07-26
+ * Author: yuan0221 (yl1452491917@gmail.com)
+ */
+
+/* Поиск */
+function dfs(i) {
+    // dp[1] и dp[2] уже известны, вернуть их
+    if (i === 1 || i === 2) return i;
+    // dp[i] = dp[i-1] + dp[i-2]
+    const count = dfs(i - 1) + dfs(i - 2);
+    return count;
+}
+
+/* Подъем по лестнице: поиск */
+function climbingStairsDFS(n) {
+    return dfs(n);
+}
+
+/* Driver Code */
+const n = 9;
+const res = climbingStairsDFS(n);
+console.log(`Количество способов подняться по лестнице из ${n} ступеней = ${res}`);

ru/codes/javascript/chapter_dynamic_programming/climbing_stairs_dfs_mem.js

@@ -0,0 +1,30 @@
+/**
+ * File: climbing_stairs_dfs_mem.js
+ * Created Time: 2023-07-26
+ * Author: yuan0221 (yl1452491917@gmail.com)
+ */
+
+/* Поиск с мемоизацией */
+function dfs(i, 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]
+    const count = dfs(i - 1, mem) + dfs(i - 2, mem);
+    // Сохранить dp[i]
+    mem[i] = count;
+    return count;
+}
+
+/* Подъем по лестнице: поиск с мемоизацией */
+function climbingStairsDFSMem(n) {
+    // mem[i] хранит число способов подняться на i-ю ступень, -1 означает отсутствие записи
+    const mem = new Array(n + 1).fill(-1);
+    return dfs(n, mem);
+}
+
+/* Driver Code */
+const n = 9;
+const res = climbingStairsDFSMem(n);
+console.log(`Количество способов подняться по лестнице из ${n} ступеней = ${res}`);

ru/codes/javascript/chapter_dynamic_programming/climbing_stairs_dp.js

@@ -0,0 +1,40 @@
+/**
+ * File: climbing_stairs_dp.js
+ * Created Time: 2023-07-26
+ * Author: yuan0221 (yl1452491917@gmail.com)
+ */
+
+/* Подъем по лестнице: динамическое программирование */
+function climbingStairsDP(n) {
+    if (n === 1 || n === 2) return n;
+    // Инициализация таблицы dp для хранения решений подзадач
+    const dp = new Array(n + 1).fill(-1);
+    // Начальное состояние: заранее задать решения наименьших подзадач
+    dp[1] = 1;
+    dp[2] = 2;
+    // Переход состояний: постепенное решение больших подзадач через меньшие
+    for (let i = 3; i <= n; i++) {
+        dp[i] = dp[i - 1] + dp[i - 2];
+    }
+    return dp[n];
+}
+
+/* Подъем по лестнице: динамическое программирование с оптимизацией памяти */
+function climbingStairsDPComp(n) {
+    if (n === 1 || n === 2) return n;
+    let a = 1,
+        b = 2;
+    for (let i = 3; i <= n; i++) {
+        const tmp = b;
+        b = a + b;
+        a = tmp;
+    }
+    return b;
+}
+
+/* Driver Code */
+const n = 9;
+let res = climbingStairsDP(n);
+console.log(`Количество способов подняться по лестнице из ${n} ступеней = ${res}`);
+res = climbingStairsDPComp(n);
+console.log(`Количество способов подняться по лестнице из ${n} ступеней = ${res}`);

ru/codes/javascript/chapter_dynamic_programming/coin_change.js

@@ -0,0 +1,66 @@
+/**
+ * File: coin_change.js
+ * Created Time: 2023-08-23
+ * Author: Gaofer Chou (gaofer-chou@qq.com)
+ */
+
+/* Размен монет: динамическое программирование */
+function coinChangeDP(coins, amt) {
+    const n = coins.length;
+    const MAX = amt + 1;
+    // Инициализация таблицы dp
+    const dp = Array.from({ length: n + 1 }, () =>
+        Array.from({ length: amt + 1 }, () => 0)
+    );
+    // Переход состояний: первая строка и первый столбец
+    for (let a = 1; a <= amt; a++) {
+        dp[0][a] = MAX;
+    }
+    // Переход состояний: остальные строки и столбцы
+    for (let i = 1; i <= n; i++) {
+        for (let a = 1; a <= amt; a++) {
+            if (coins[i - 1] > a) {
+                // Если целевая сумма превышена, монету i не выбирать
+                dp[i][a] = dp[i - 1][a];
+            } else {
+                // Меньшее из двух решений: не брать или взять монету i
+                dp[i][a] = Math.min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);
+            }
+        }
+    }
+    return dp[n][amt] !== MAX ? dp[n][amt] : -1;
+}
+
+/* Размен монет: динамическое программирование с оптимизацией памяти */
+function coinChangeDPComp(coins, amt) {
+    const n = coins.length;
+    const MAX = amt + 1;
+    // Инициализация таблицы dp
+    const dp = Array.from({ length: amt + 1 }, () => MAX);
+    dp[0] = 0;
+    // Переход состояний
+    for (let i = 1; i <= n; i++) {
+        for (let a = 1; a <= amt; a++) {
+            if (coins[i - 1] > a) {
+                // Если целевая сумма превышена, монету i не выбирать
+                dp[a] = dp[a];
+            } else {
+                // Меньшее из двух решений: не брать или взять монету i
+                dp[a] = Math.min(dp[a], dp[a - coins[i - 1]] + 1);
+            }
+        }
+    }
+    return dp[amt] !== MAX ? dp[amt] : -1;
+}
+
+/* Driver Code */
+const coins = [1, 2, 5];
+const amt = 4;
+
+// Динамическое программирование
+let res = coinChangeDP(coins, amt);
+console.log(`Минимальное число монет для набора целевой суммы = ${res}`);
+
+// Динамическое программирование с оптимизацией памяти
+res = coinChangeDPComp(coins, amt);
+console.log(`Минимальное число монет для набора целевой суммы = ${res}`);

ru/codes/javascript/chapter_dynamic_programming/coin_change_ii.js

@@ -0,0 +1,64 @@
+/**
+ * File: coin_change_ii.js
+ * Created Time: 2023-08-23
+ * Author: Gaofer Chou (gaofer-chou@qq.com)
+ */
+
+/* Размен монет II: динамическое программирование */
+function coinChangeIIDP(coins, amt) {
+    const n = coins.length;
+    // Инициализация таблицы dp
+    const dp = Array.from({ length: n + 1 }, () =>
+        Array.from({ length: amt + 1 }, () => 0)
+    );
+    // Инициализация первого столбца
+    for (let i = 0; i <= n; i++) {
+        dp[i][0] = 1;
+    }
+    // Переход состояний
+    for (let i = 1; i <= n; i++) {
+        for (let 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: динамическое программирование с оптимизацией памяти */
+function coinChangeIIDPComp(coins, amt) {
+    const n = coins.length;
+    // Инициализация таблицы dp
+    const dp = Array.from({ length: amt + 1 }, () => 0);
+    dp[0] = 1;
+    // Переход состояний
+    for (let i = 1; i <= n; i++) {
+        for (let 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 */
+const coins = [1, 2, 5];
+const amt = 5;
+
+// Динамическое программирование
+let res = coinChangeIIDP(coins, amt);
+console.log(`Количество комбинаций монет для набора целевой суммы = ${res}`);
+
+// Динамическое программирование с оптимизацией памяти
+res = coinChangeIIDPComp(coins, amt);
+console.log(`Количество комбинаций монет для набора целевой суммы = ${res}`);

ru/codes/javascript/chapter_dynamic_programming/edit_distance.js

@@ -0,0 +1,135 @@
+/**
+ * File: edit_distance.js
+ * Created Time: 2023-08-23
+ * Author: Gaofer Chou (gaofer-chou@qq.com)
+ */
+
+/* Редакционное расстояние: полный перебор */
+function editDistanceDFS(s, t, i, j) {
+    // Если s и t пусты, вернуть 0
+    if (i === 0 && j === 0) return 0;
+
+    // Если s пусто, вернуть длину t
+    if (i === 0) return j;
+
+    // Если t пусто, вернуть длину s
+    if (j === 0) return i;
+
+    // Если два символа равны, сразу пропустить их
+    if (s.charAt(i - 1) === t.charAt(j - 1))
+        return editDistanceDFS(s, t, i - 1, j - 1);
+
+    // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1
+    const insert = editDistanceDFS(s, t, i, j - 1);
+    const del = editDistanceDFS(s, t, i - 1, j);
+    const replace = editDistanceDFS(s, t, i - 1, j - 1);
+    // Вернуть минимальное число шагов редактирования
+    return Math.min(insert, del, replace) + 1;
+}
+
+/* Редакционное расстояние: поиск с мемоизацией */
+function editDistanceDFSMem(s, t, mem, i, j) {
+    // Если s и t пусты, вернуть 0
+    if (i === 0 && j === 0) return 0;
+
+    // Если s пусто, вернуть длину t
+    if (i === 0) return j;
+
+    // Если t пусто, вернуть длину s
+    if (j === 0) return i;
+
+    // Если запись уже есть, сразу вернуть ее
+    if (mem[i][j] !== -1) return mem[i][j];
+
+    // Если два символа равны, сразу пропустить их
+    if (s.charAt(i - 1) === t.charAt(j - 1))
+        return editDistanceDFSMem(s, t, mem, i - 1, j - 1);
+
+    // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1
+    const insert = editDistanceDFSMem(s, t, mem, i, j - 1);
+    const del = editDistanceDFSMem(s, t, mem, i - 1, j);
+    const replace = editDistanceDFSMem(s, t, mem, i - 1, j - 1);
+    // Сохранить и вернуть минимальное число шагов редактирования
+    mem[i][j] = Math.min(insert, del, replace) + 1;
+    return mem[i][j];
+}
+
+/* Редакционное расстояние: динамическое программирование */
+function editDistanceDP(s, t) {
+    const n = s.length,
+        m = t.length;
+    const dp = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
+    // Переход состояний: первая строка и первый столбец
+    for (let i = 1; i <= n; i++) {
+        dp[i][0] = i;
+    }
+    for (let j = 1; j <= m; j++) {
+        dp[0][j] = j;
+    }
+    // Переход состояний: остальные строки и столбцы
+    for (let i = 1; i <= n; i++) {
+        for (let j = 1; j <= m; j++) {
+            if (s.charAt(i - 1) === t.charAt(j - 1)) {
+                // Если два символа равны, сразу пропустить их
+                dp[i][j] = dp[i - 1][j - 1];
+            } else {
+                // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1
+                dp[i][j] =
+                    Math.min(dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]) + 1;
+            }
+        }
+    }
+    return dp[n][m];
+}
+
+/* Редакционное расстояние: динамическое программирование с оптимизацией памяти */
+function editDistanceDPComp(s, t) {
+    const n = s.length,
+        m = t.length;
+    const dp = new Array(m + 1).fill(0);
+    // Переход состояний: первая строка
+    for (let j = 1; j <= m; j++) {
+        dp[j] = j;
+    }
+    // Переход состояний: остальные строки
+    for (let i = 1; i <= n; i++) {
+        // Переход состояний: первый столбец
+        let leftup = dp[0]; // Временно сохранить dp[i-1, j-1]
+        dp[0] = i;
+        // Переход состояний: остальные столбцы
+        for (let j = 1; j <= m; j++) {
+            const temp = dp[j];
+            if (s.charAt(i - 1) === t.charAt(j - 1)) {
+                // Если два символа равны, сразу пропустить их
+                dp[j] = leftup;
+            } else {
+                // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1
+                dp[j] = Math.min(dp[j - 1], dp[j], leftup) + 1;
+            }
+            leftup = temp; // Обновить до значения dp[i-1, j-1] для следующей итерации
+        }
+    }
+    return dp[m];
+}
+
+const s = 'bag';
+const t = 'pack';
+const n = s.length,
+    m = t.length;
+
+// Полный перебор
+let res = editDistanceDFS(s, t, n, m);
+console.log(`Чтобы преобразовать ${s} в ${t}, нужно минимум ${res} шагов`);
+
+// Поиск с мемоизацией
+const mem = Array.from(new Array(n + 1), () => new Array(m + 1).fill(-1));
+res = editDistanceDFSMem(s, t, mem, n, m);
+console.log(`Чтобы преобразовать ${s} в ${t}, нужно минимум ${res} шагов`);
+
+// Динамическое программирование
+res = editDistanceDP(s, t);
+console.log(`Чтобы преобразовать ${s} в ${t}, нужно минимум ${res} шагов`);
+
+// Динамическое программирование с оптимизацией памяти
+res = editDistanceDPComp(s, t);
+console.log(`Чтобы преобразовать ${s} в ${t}, нужно минимум ${res} шагов`);

ru/codes/javascript/chapter_dynamic_programming/knapsack.js

@@ -0,0 +1,113 @@
+/**
+ * File: knapsack.js
+ * Created Time: 2023-08-23
+ * Author: Gaofer Chou (gaofer-chou@qq.com)
+ */
+
+/* Рюкзак 0-1: полный перебор */
+function knapsackDFS(wgt, val, i, c) {
+    // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0
+    if (i === 0 || c === 0) {
+        return 0;
+    }
+    // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак
+    if (wgt[i - 1] > c) {
+        return knapsackDFS(wgt, val, i - 1, c);
+    }
+    // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут
+    const no = knapsackDFS(wgt, val, i - 1, c);
+    const yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];
+    // Вернуть вариант с большей стоимостью из двух возможных
+    return Math.max(no, yes);
+}
+
+/* Рюкзак 0-1: поиск с мемоизацией */
+function knapsackDFSMem(wgt, val, mem, i, 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 не кладут и кладут
+    const no = knapsackDFSMem(wgt, val, mem, i - 1, c);
+    const yes =
+        knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];
+    // Сохранить и вернуть вариант с большей стоимостью из двух решений
+    mem[i][c] = Math.max(no, yes);
+    return mem[i][c];
+}
+
+/* Рюкзак 0-1: динамическое программирование */
+function knapsackDP(wgt, val, cap) {
+    const n = wgt.length;
+    // Инициализация таблицы dp
+    const dp = Array(n + 1)
+        .fill(0)
+        .map(() => Array(cap + 1).fill(0));
+    // Переход состояний
+    for (let i = 1; i <= n; i++) {
+        for (let c = 1; c <= cap; c++) {
+            if (wgt[i - 1] > c) {
+                // Если вместимость рюкзака превышена, предмет i не выбирать
+                dp[i][c] = dp[i - 1][c];
+            } else {
+                // Большее из двух решений: не брать или взять предмет i
+                dp[i][c] = Math.max(
+                    dp[i - 1][c],
+                    dp[i - 1][c - wgt[i - 1]] + val[i - 1]
+                );
+            }
+        }
+    }
+    return dp[n][cap];
+}
+
+/* Рюкзак 0-1: динамическое программирование с оптимизацией памяти */
+function knapsackDPComp(wgt, val, cap) {
+    const n = wgt.length;
+    // Инициализация таблицы dp
+    const dp = Array(cap + 1).fill(0);
+    // Переход состояний
+    for (let i = 1; i <= n; i++) {
+        // Обход в обратном порядке
+        for (let c = cap; c >= 1; c--) {
+            if (wgt[i - 1] <= c) {
+                // Большее из двух решений: не брать или взять предмет i
+                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);
+            }
+        }
+    }
+    return dp[cap];
+}
+
+/* Driver Code */
+const wgt = [10, 20, 30, 40, 50];
+const val = [50, 120, 150, 210, 240];
+const cap = 50;
+const n = wgt.length;
+
+// Полный перебор
+let res = knapsackDFS(wgt, val, n, cap);
+console.log(`Максимальная стоимость предметов без превышения вместимости рюкзака = ${res}`);
+
+// Поиск с мемоизацией
+const mem = Array.from({ length: n + 1 }, () =>
+    Array.from({ length: cap + 1 }, () => -1)
+);
+res = knapsackDFSMem(wgt, val, mem, n, cap);
+console.log(`Максимальная стоимость предметов без превышения вместимости рюкзака = ${res}`);
+
+// Динамическое программирование
+res = knapsackDP(wgt, val, cap);
+console.log(`Максимальная стоимость предметов без превышения вместимости рюкзака = ${res}`);
+
+// Динамическое программирование с оптимизацией памяти
+res = knapsackDPComp(wgt, val, cap);
+console.log(`Максимальная стоимость предметов без превышения вместимости рюкзака = ${res}`);

ru/codes/javascript/chapter_dynamic_programming/min_cost_climbing_stairs_dp.js

@@ -0,0 +1,49 @@
+/**
+ * File: min_cost_climbing_stairs_dp.js
+ * Created Time: 2023-08-23
+ * Author: Gaofer Chou (gaofer-chou@qq.com)
+ */
+
+/* Минимальная стоимость подъема по лестнице: динамическое программирование */
+function minCostClimbingStairsDP(cost) {
+    const n = cost.length - 1;
+    if (n === 1 || n === 2) {
+        return cost[n];
+    }
+    // Инициализация таблицы dp для хранения решений подзадач
+    const dp = new Array(n + 1);
+    // Начальное состояние: заранее задать решения наименьших подзадач
+    dp[1] = cost[1];
+    dp[2] = cost[2];
+    // Переход состояний: постепенное решение больших подзадач через меньшие
+    for (let i = 3; i <= n; i++) {
+        dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];
+    }
+    return dp[n];
+}
+
+/* Минимальная стоимость подъема по лестнице: динамическое программирование с оптимизацией памяти */
+function minCostClimbingStairsDPComp(cost) {
+    const n = cost.length - 1;
+    if (n === 1 || n === 2) {
+        return cost[n];
+    }
+    let a = cost[1],
+        b = cost[2];
+    for (let i = 3; i <= n; i++) {
+        const tmp = b;
+        b = Math.min(a, tmp) + cost[i];
+        a = tmp;
+    }
+    return b;
+}
+
+/* Driver Code */
+const cost = [0, 1, 10, 1, 1, 1, 10, 1, 1, 10, 1];
+console.log('Список стоимостей ступеней =', cost);
+
+let res = minCostClimbingStairsDP(cost);
+console.log(`Минимальная стоимость подъема по лестнице = ${res}`);
+
+res = minCostClimbingStairsDPComp(cost);
+console.log(`Минимальная стоимость подъема по лестнице = ${res}`);

ru/codes/javascript/chapter_dynamic_programming/min_path_sum.js

@@ -0,0 +1,121 @@
+/**
+ * File: min_path_sum.js
+ * Created Time: 2023-08-23
+ * Author: Gaofer Chou (gaofer-chou@qq.com)
+ */
+
+/* Минимальная сумма пути: полный перебор */
+function minPathSumDFS(grid, i, j) {
+    // Если это верхняя левая ячейка, завершить поиск
+    if (i === 0 && j === 0) {
+        return grid[0][0];
+    }
+    // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞
+    if (i < 0 || j < 0) {
+        return Infinity;
+    }
+    // Вычислить минимальную стоимость пути из левого верхнего угла до (i-1, j) и (i, j-1)
+    const up = minPathSumDFS(grid, i - 1, j);
+    const left = minPathSumDFS(grid, i, j - 1);
+    // Вернуть минимальную стоимость пути из левого верхнего угла до (i, j)
+    return Math.min(left, up) + grid[i][j];
+}
+
+/* Минимальная сумма пути: поиск с мемоизацией */
+function minPathSumDFSMem(grid, mem, i, j) {
+    // Если это верхняя левая ячейка, завершить поиск
+    if (i === 0 && j === 0) {
+        return grid[0][0];
+    }
+    // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞
+    if (i < 0 || j < 0) {
+        return Infinity;
+    }
+    // Если запись уже есть, вернуть сразу
+    if (mem[i][j] !== -1) {
+        return mem[i][j];
+    }
+    // Минимальная стоимость пути для левой и верхней ячеек
+    const up = minPathSumDFSMem(grid, mem, i - 1, j);
+    const left = minPathSumDFSMem(grid, mem, i, j - 1);
+    // Сохранить и вернуть минимальную стоимость пути из левого верхнего угла до (i, j)
+    mem[i][j] = Math.min(left, up) + grid[i][j];
+    return mem[i][j];
+}
+
+/* Минимальная сумма пути: динамическое программирование */
+function minPathSumDP(grid) {
+    const n = grid.length,
+        m = grid[0].length;
+    // Инициализация таблицы dp
+    const dp = Array.from({ length: n }, () =>
+        Array.from({ length: m }, () => 0)
+    );
+    dp[0][0] = grid[0][0];
+    // Переход состояний: первая строка
+    for (let j = 1; j < m; j++) {
+        dp[0][j] = dp[0][j - 1] + grid[0][j];
+    }
+    // Переход состояний: первый столбец
+    for (let i = 1; i < n; i++) {
+        dp[i][0] = dp[i - 1][0] + grid[i][0];
+    }
+    // Переход состояний: остальные строки и столбцы
+    for (let i = 1; i < n; i++) {
+        for (let j = 1; j < m; j++) {
+            dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];
+        }
+    }
+    return dp[n - 1][m - 1];
+}
+
+/* Минимальная сумма пути: динамическое программирование с оптимизацией памяти */
+function minPathSumDPComp(grid) {
+    const n = grid.length,
+        m = grid[0].length;
+    // Инициализация таблицы dp
+    const dp = new Array(m);
+    // Переход состояний: первая строка
+    dp[0] = grid[0][0];
+    for (let j = 1; j < m; j++) {
+        dp[j] = dp[j - 1] + grid[0][j];
+    }
+    // Переход состояний: остальные строки
+    for (let i = 1; i < n; i++) {
+        // Переход состояний: первый столбец
+        dp[0] = dp[0] + grid[i][0];
+        // Переход состояний: остальные столбцы
+        for (let j = 1; j < m; j++) {
+            dp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];
+        }
+    }
+    return dp[m - 1];
+}
+
+/* Driver Code */
+const grid = [
+    [1, 3, 1, 5],
+    [2, 2, 4, 2],
+    [5, 3, 2, 1],
+    [4, 3, 5, 2],
+];
+const n = grid.length,
+    m = grid[0].length;
+// Полный перебор
+let res = minPathSumDFS(grid, n - 1, m - 1);
+console.log(`Минимальная сумма пути из левого верхнего угла в правый нижний = ${res}`);
+
+// Поиск с мемоизацией
+const mem = Array.from({ length: n }, () =>
+    Array.from({ length: m }, () => -1)
+);
+res = minPathSumDFSMem(grid, mem, n - 1, m - 1);
+console.log(`Минимальная сумма пути из левого верхнего угла в правый нижний = ${res}`);
+
+// Динамическое программирование
+res = minPathSumDP(grid);
+console.log(`Минимальная сумма пути из левого верхнего угла в правый нижний = ${res}`);
+
+// Динамическое программирование с оптимизацией памяти
+res = minPathSumDPComp(grid);
+console.log(`Минимальная сумма пути из левого верхнего угла в правый нижний = ${res}`);

ru/codes/javascript/chapter_dynamic_programming/unbounded_knapsack.js

@@ -0,0 +1,63 @@
+/**
+ * File: unbounded_knapsack.js
+ * Created Time: 2023-08-23
+ * Author: Gaofer Chou (gaofer-chou@qq.com)
+ */
+
+/* Полный рюкзак: динамическое программирование */
+function unboundedKnapsackDP(wgt, val, cap) {
+    const n = wgt.length;
+    // Инициализация таблицы dp
+    const dp = Array.from({ length: n + 1 }, () =>
+        Array.from({ length: cap + 1 }, () => 0)
+    );
+    // Переход состояний
+    for (let i = 1; i <= n; i++) {
+        for (let c = 1; c <= cap; c++) {
+            if (wgt[i - 1] > c) {
+                // Если вместимость рюкзака превышена, предмет i не выбирать
+                dp[i][c] = dp[i - 1][c];
+            } else {
+                // Большее из двух решений: не брать или взять предмет i
+                dp[i][c] = Math.max(
+                    dp[i - 1][c],
+                    dp[i][c - wgt[i - 1]] + val[i - 1]
+                );
+            }
+        }
+    }
+    return dp[n][cap];
+}
+
+/* Полный рюкзак: динамическое программирование с оптимизацией памяти */
+function unboundedKnapsackDPComp(wgt, val, cap) {
+    const n = wgt.length;
+    // Инициализация таблицы dp
+    const dp = Array.from({ length: cap + 1 }, () => 0);
+    // Переход состояний
+    for (let i = 1; i <= n; i++) {
+        for (let c = 1; c <= cap; c++) {
+            if (wgt[i - 1] > c) {
+                // Если вместимость рюкзака превышена, предмет i не выбирать
+                dp[c] = dp[c];
+            } else {
+                // Большее из двух решений: не брать или взять предмет i
+                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);
+            }
+        }
+    }
+    return dp[cap];
+}
+
+/* Driver Code */
+const wgt = [1, 2, 3];
+const val = [5, 11, 15];
+const cap = 4;
+
+// Динамическое программирование
+let res = unboundedKnapsackDP(wgt, val, cap);
+console.log(`Максимальная стоимость предметов без превышения вместимости рюкзака = ${res}`);
+
+// Динамическое программирование с оптимизацией памяти
+res = unboundedKnapsackDPComp(wgt, val, cap);
+console.log(`Максимальная стоимость предметов без превышения вместимости рюкзака = ${res}`);

ru/codes/javascript/chapter_graph/graph_adjacency_list.js

@@ -0,0 +1,142 @@
+/**
+ * File: graph_adjacency_list.js
+ * Created Time: 2023-02-09
+ * Author: Justin (xiefahit@gmail.com)
+ */
+
+const { Vertex } = require('../modules/Vertex');
+
+/* Класс неориентированного графа на основе списка смежности */
+class GraphAdjList {
+    // Список смежности, где key — вершина, а value — все смежные ей вершины
+    adjList;
+
+    /* Конструктор */
+    constructor(edges) {
+        this.adjList = new Map();
+        // Добавить все вершины и ребра
+        for (const edge of edges) {
+            this.addVertex(edge[0]);
+            this.addVertex(edge[1]);
+            this.addEdge(edge[0], edge[1]);
+        }
+    }
+
+    /* Получить число вершин */
+    size() {
+        return this.adjList.size;
+    }
+
+    /* Добавление ребра */
+    addEdge(vet1, vet2) {
+        if (
+            !this.adjList.has(vet1) ||
+            !this.adjList.has(vet2) ||
+            vet1 === vet2
+        ) {
+            throw new Error('Illegal Argument Exception');
+        }
+        // Добавить ребро vet1 - vet2
+        this.adjList.get(vet1).push(vet2);
+        this.adjList.get(vet2).push(vet1);
+    }
+
+    /* Удаление ребра */
+    removeEdge(vet1, vet2) {
+        if (
+            !this.adjList.has(vet1) ||
+            !this.adjList.has(vet2) ||
+            vet1 === vet2 ||
+            this.adjList.get(vet1).indexOf(vet2) === -1
+        ) {
+            throw new Error('Illegal Argument Exception');
+        }
+        // Удалить ребро vet1 - vet2
+        this.adjList.get(vet1).splice(this.adjList.get(vet1).indexOf(vet2), 1);
+        this.adjList.get(vet2).splice(this.adjList.get(vet2).indexOf(vet1), 1);
+    }
+
+    /* Добавление вершины */
+    addVertex(vet) {
+        if (this.adjList.has(vet)) return;
+        // Добавить новый список в список смежности
+        this.adjList.set(vet, []);
+    }
+
+    /* Удаление вершины */
+    removeVertex(vet) {
+        if (!this.adjList.has(vet)) {
+            throw new Error('Illegal Argument Exception');
+        }
+        // Удалить из списка смежности список, соответствующий вершине vet
+        this.adjList.delete(vet);
+        // Обойти списки других вершин и удалить все ребра, содержащие vet
+        for (const set of this.adjList.values()) {
+            const index = set.indexOf(vet);
+            if (index > -1) {
+                set.splice(index, 1);
+            }
+        }
+    }
+
+    /* Вывести список смежности */
+    print() {
+        console.log('Список смежности =');
+        for (const [key, value] of this.adjList) {
+            const tmp = [];
+            for (const vertex of value) {
+                tmp.push(vertex.val);
+            }
+            console.log(key.val + ': ' + tmp.join());
+        }
+    }
+}
+
+if (require.main === module) {
+    /* Driver Code */
+    /* Инициализация неориентированного графа */
+    const v0 = new Vertex(1),
+        v1 = new Vertex(3),
+        v2 = new Vertex(2),
+        v3 = new Vertex(5),
+        v4 = new Vertex(4);
+    const edges = [
+        [v0, v1],
+        [v1, v2],
+        [v2, v3],
+        [v0, v3],
+        [v2, v4],
+        [v3, v4],
+    ];
+    const graph = new GraphAdjList(edges);
+    console.log('\nГраф после инициализации');
+    graph.print();
+
+    /* Добавление ребра */
+    // Вершины 1 и 2 соответствуют v0 и v2
+    graph.addEdge(v0, v2);
+    console.log('\nГраф после добавления ребра 1-2');
+    graph.print();
+
+    /* Удаление ребра */
+    // Вершины 1 и 3 соответствуют v0 и v1
+    graph.removeEdge(v0, v1);
+    console.log('\nГраф после удаления ребра 1-3');
+    graph.print();
+
+    /* Добавление вершины */
+    const v5 = new Vertex(6);
+    graph.addVertex(v5);
+    console.log('\nГраф после добавления вершины 6');
+    graph.print();
+
+    /* Удаление вершины */
+    // Вершина 3 соответствует v1
+    graph.removeVertex(v1);
+    console.log('\nГраф после удаления вершины 3');
+    graph.print();
+}
+
+module.exports = {
+    GraphAdjList,
+};

ru/codes/javascript/chapter_graph/graph_adjacency_matrix.js

@@ -0,0 +1,132 @@
+/**
+ * File: graph_adjacency_matrix.js
+ * Created Time: 2023-02-09
+ * Author: Zhuo Qinyue (1403450829@qq.com)
+ */
+
+/* Класс неориентированного графа на основе матрицы смежности */
+class GraphAdjMat {
+    vertices; // Список вершин: элементы представляют «значения вершин», а индексы — «индексы вершин»
+    adjMat; // Матрица смежности, где индексы строк и столбцов соответствуют «индексам вершин»
+
+    /* Конструктор */
+    constructor(vertices, edges) {
+        this.vertices = [];
+        this.adjMat = [];
+        // Добавление вершины
+        for (const val of vertices) {
+            this.addVertex(val);
+        }
+        // Добавить ребра
+        // Обратите внимание: элементы edges представляют собой индексы вершин, то есть соответствуют индексам элементов vertices
+        for (const e of edges) {
+            this.addEdge(e[0], e[1]);
+        }
+    }
+
+    /* Получить число вершин */
+    size() {
+        return this.vertices.length;
+    }
+
+    /* Добавление вершины */
+    addVertex(val) {
+        const n = this.size();
+        // Добавить значение новой вершины в список вершин
+        this.vertices.push(val);
+        // Добавить строку в матрицу смежности
+        const newRow = [];
+        for (let j = 0; j < n; j++) {
+            newRow.push(0);
+        }
+        this.adjMat.push(newRow);
+        // Добавить столбец в матрицу смежности
+        for (const row of this.adjMat) {
+            row.push(0);
+        }
+    }
+
+    /* Удаление вершины */
+    removeVertex(index) {
+        if (index >= this.size()) {
+            throw new RangeError('Index Out Of Bounds Exception');
+        }
+        // Удалить вершину с индексом index из списка вершин
+        this.vertices.splice(index, 1);
+
+        // Удалить строку с индексом index из матрицы смежности
+        this.adjMat.splice(index, 1);
+        // Удалить столбец с индексом index из матрицы смежности
+        for (const row of this.adjMat) {
+            row.splice(index, 1);
+        }
+    }
+
+    /* Добавление ребра */
+    // Параметры i и j соответствуют индексам элементов vertices
+    addEdge(i, j) {
+        // Обработка выхода индекса за границы и случая равенства
+        if (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {
+            throw new RangeError('Index Out Of Bounds Exception');
+        }
+        // В неориентированном графе матрица смежности симметрична относительно главной диагонали, то есть выполняется (i, j) === (j, i)
+        this.adjMat[i][j] = 1;
+        this.adjMat[j][i] = 1;
+    }
+
+    /* Удаление ребра */
+    // Параметры i и j соответствуют индексам элементов vertices
+    removeEdge(i, j) {
+        // Обработка выхода индекса за границы и случая равенства
+        if (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {
+            throw new RangeError('Index Out Of Bounds Exception');
+        }
+        this.adjMat[i][j] = 0;
+        this.adjMat[j][i] = 0;
+    }
+
+    /* Вывести матрицу смежности */
+    print() {
+        console.log('Список вершин = ', this.vertices);
+        console.log('Матрица смежности =', this.adjMat);
+    }
+}
+
+/* Driver Code */
+/* Инициализация неориентированного графа */
+// Обратите внимание: элементы edges представляют индексы вершин, то есть соответствуют индексам элементов vertices
+const vertices = [1, 3, 2, 5, 4];
+const edges = [
+    [0, 1],
+    [1, 2],
+    [2, 3],
+    [0, 3],
+    [2, 4],
+    [3, 4],
+];
+const graph = new GraphAdjMat(vertices, edges);
+console.log('\nГраф после инициализации');
+graph.print();
+
+/* Добавление ребра */
+// Индексы вершин 1 и 2 равны 0 и 2 соответственно
+graph.addEdge(0, 2);
+console.log('\nГраф после добавления ребра 1-2');
+graph.print();
+
+/* Удаление ребра */
+// Индексы вершин 1 и 3 равны 0 и 1 соответственно
+graph.removeEdge(0, 1);
+console.log('\nГраф после удаления ребра 1-3');
+graph.print();
+
+/* Добавление вершины */
+graph.addVertex(6);
+console.log('\nГраф после добавления вершины 6');
+graph.print();
+
+/* Удаление вершины */
+// Индекс вершины 3 равен 1
+graph.removeVertex(1);
+console.log('\nГраф после удаления вершины 3');
+graph.print();

ru/codes/javascript/chapter_graph/graph_bfs.js

@@ -0,0 +1,61 @@
+/**
+ * File: graph_bfs.js
+ * Created Time: 2023-02-21
+ * Author: Zhuo Qinyue (1403450829@qq.com)
+ */
+
+const { GraphAdjList } = require('./graph_adjacency_list');
+const { Vertex } = require('../modules/Vertex');
+
+/* Обход в ширину */
+// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины
+function graphBFS(graph, startVet) {
+    // Последовательность обхода вершин
+    const res = [];
+    // Хеш-множество для хранения уже посещенных вершин
+    const visited = new Set();
+    visited.add(startVet);
+    // Очередь используется для реализации BFS
+    const que = [startVet];
+    // Начиная с вершины vet, продолжать цикл, пока не будут посещены все вершины
+    while (que.length) {
+        const vet = que.shift(); // Извлечь головную вершину из очереди
+        res.push(vet); // Отметить посещенную вершину
+        // Обойти все смежные вершины данной вершины
+        for (const adjVet of graph.adjList.get(vet) ?? []) {
+            if (visited.has(adjVet)) {
+                continue; // Пропустить уже посещенную вершину
+            }
+            que.push(adjVet); // Помещать в очередь только непосещенные вершины
+            visited.add(adjVet); // Отметить эту вершину как посещенную
+        }
+    }
+    // Вернуть последовательность обхода вершин
+    return res;
+}
+
+/* Driver Code */
+/* Инициализация неориентированного графа */
+const v = Vertex.valsToVets([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
+const 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]],
+];
+const graph = new GraphAdjList(edges);
+console.log('\nГраф после инициализации');
+graph.print();
+
+/* Обход в ширину */
+const res = graphBFS(graph, v[0]);
+console.log('\nПоследовательность вершин при обходе в ширину (BFS)');
+console.log(Vertex.vetsToVals(res));

ru/codes/javascript/chapter_graph/graph_dfs.js

@@ -0,0 +1,54 @@
+/**
+ * File: graph_dfs.js
+ * Created Time: 2023-02-21
+ * Author: Zhuo Qinyue (1403450829@qq.com)
+ */
+
+const { Vertex } = require('../modules/Vertex');
+const { GraphAdjList } = require('./graph_adjacency_list');
+
+/* Обход в глубину */
+// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины
+function dfs(graph, visited, res, vet) {
+    res.push(vet); // Отметить посещенную вершину
+    visited.add(vet); // Отметить эту вершину как посещенную
+    // Обойти все смежные вершины данной вершины
+    for (const adjVet of graph.adjList.get(vet)) {
+        if (visited.has(adjVet)) {
+            continue; // Пропустить уже посещенную вершину
+        }
+        // Рекурсивно обходить смежные вершины
+        dfs(graph, visited, res, adjVet);
+    }
+}
+
+/* Обход в глубину */
+// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины
+function graphDFS(graph, startVet) {
+    // Последовательность обхода вершин
+    const res = [];
+    // Хеш-множество для хранения уже посещенных вершин
+    const visited = new Set();
+    dfs(graph, visited, res, startVet);
+    return res;
+}
+
+/* Driver Code */
+/* Инициализация неориентированного графа */
+const v = Vertex.valsToVets([0, 1, 2, 3, 4, 5, 6]);
+const 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]],
+];
+const graph = new GraphAdjList(edges);
+console.log('\nГраф после инициализации');
+graph.print();
+
+/* Обход в глубину */
+const res = graphDFS(graph, v[0]);
+console.log('\nПоследовательность вершин при обходе в глубину (DFS)');
+console.log(Vertex.vetsToVals(res));

ru/codes/javascript/chapter_greedy/coin_change_greedy.js

@@ -0,0 +1,48 @@
+/**
+ * File: coin_change_greedy.js
+ * Created Time: 2023-09-02
+ * Author: Justin (xiefahit@gmail.com)
+ */
+
+/* Размен монет: жадный алгоритм */
+function coinChangeGreedy(coins, amt) {
+    // Предположить, что массив coins упорядочен
+    let i = coins.length - 1;
+    let 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 */
+// Жадный подход: гарантирует нахождение глобально оптимального решения
+let coins = [1, 5, 10, 20, 50, 100];
+let amt = 186;
+let res = coinChangeGreedy(coins, amt);
+console.log(`\ncoins = ${coins}, amt = ${amt}`);
+console.log(`Минимальное число монет для набора суммы ${amt} = ${res}`);
+
+// Жадный подход: не гарантирует нахождение глобально оптимального решения
+coins = [1, 20, 50];
+amt = 60;
+res = coinChangeGreedy(coins, amt);
+console.log(`\ncoins = ${coins}, amt = ${amt}`);
+console.log(`Минимальное число монет для набора суммы ${amt} = ${res}`);
+console.log('На самом деле минимум равен 3: 20 + 20 + 20');
+
+// Жадный подход: не гарантирует нахождение глобально оптимального решения
+coins = [1, 49, 50];
+amt = 98;
+res = coinChangeGreedy(coins, amt);
+console.log(`\ncoins = ${coins}, amt = ${amt}`);
+console.log(`Минимальное число монет для набора суммы ${amt} = ${res}`);
+console.log('На самом деле минимум равен 2: 49 + 49');

ru/codes/javascript/chapter_greedy/fractional_knapsack.js

@@ -0,0 +1,46 @@
+/**
+ * File: fractional_knapsack.js
+ * Created Time: 2023-09-02
+ * Author: Justin (xiefahit@gmail.com)
+ */
+
+/* Предмет */
+class Item {
+    constructor(w, v) {
+        this.w = w; // Вес предмета
+        this.v = v; // Стоимость предмета
+    }
+}
+
+/* Дробный рюкзак: жадный алгоритм */
+function fractionalKnapsack(wgt, val, cap) {
+    // Создать список предметов с двумя свойствами: вес и стоимость
+    const items = wgt.map((w, i) => new Item(w, val[i]));
+    // Отсортировать по удельной стоимости item.v / item.w в порядке убывания
+    items.sort((a, b) => b.v / b.w - a.v / a.w);
+    // Циклический жадный выбор
+    let res = 0;
+    for (const item of items) {
+        if (item.w <= cap) {
+            // Если оставшейся вместимости достаточно, положить в рюкзак текущий предмет целиком
+            res += item.v;
+            cap -= item.w;
+        } else {
+            // Если оставшейся вместимости недостаточно, положить в рюкзак часть текущего предмета
+            res += (item.v / item.w) * cap;
+            // Свободной вместимости больше не осталось, поэтому выйти из цикла
+            break;
+        }
+    }
+    return res;
+}
+
+/* Driver Code */
+const wgt = [10, 20, 30, 40, 50];
+const val = [50, 120, 150, 210, 240];
+const cap = 50;
+const n = wgt.length;
+
+// Жадный алгоритм
+const res = fractionalKnapsack(wgt, val, cap);
+console.log(`Максимальная стоимость предметов без превышения вместимости рюкзака = ${res}`);

ru/codes/javascript/chapter_greedy/max_capacity.js

@@ -0,0 +1,34 @@
+/**
+ * File: max_capacity.js
+ * Created Time: 2023-09-02
+ * Author: Justin (xiefahit@gmail.com)
+ */
+
+/* Максимальная вместимость: жадный алгоритм */
+function maxCapacity(ht) {
+    // Инициализировать i и j так, чтобы они располагались по двум концам массива
+    let i = 0,
+        j = ht.length - 1;
+    // Начальная максимальная вместимость равна 0
+    let res = 0;
+    // Выполнять жадный выбор в цикле, пока две доски не встретятся
+    while (i < j) {
+        // Обновить максимальную вместимость
+        const cap = Math.min(ht[i], ht[j]) * (j - i);
+        res = Math.max(res, cap);
+        // Сдвигать внутрь более короткую сторону
+        if (ht[i] < ht[j]) {
+            i += 1;
+        } else {
+            j -= 1;
+        }
+    }
+    return res;
+}
+
+/* Driver Code */
+const ht = [3, 8, 5, 2, 7, 7, 3, 4];
+
+// Жадный алгоритм
+const res = maxCapacity(ht);
+console.log(`Максимальная вместимость = ${res}`);

ru/codes/javascript/chapter_greedy/max_product_cutting.js

@@ -0,0 +1,33 @@
+/**
+ * File: max_product_cutting.js
+ * Created Time: 2023-09-02
+ * Author: Justin (xiefahit@gmail.com)
+ */
+
+/* Максимальное произведение разрезания: жадный алгоритм */
+function maxProductCutting(n) {
+    // Когда n <= 3, обязательно нужно выделить одну 1
+    if (n <= 3) {
+        return 1 * (n - 1);
+    }
+    // Жадно выделить множители 3, где a — число троек, а b — остаток
+    let a = Math.floor(n / 3);
+    let b = n % 3;
+    if (b === 1) {
+        // Если остаток равен 1, преобразовать одну пару 1 * 3 в 2 * 2
+        return Math.pow(3, a - 1) * 2 * 2;
+    }
+    if (b === 2) {
+        // Если остаток равен 2, ничего не делать
+        return Math.pow(3, a) * 2;
+    }
+    // Если остаток равен 0, ничего не делать
+    return Math.pow(3, a);
+}
+
+/* Driver Code */
+let n = 58;
+
+// Жадный алгоритм
+let res = maxProductCutting(n);
+console.log(`Максимальное произведение после разрезания = ${res}`);

ru/codes/javascript/chapter_hashing/array_hash_map.js

@@ -0,0 +1,128 @@
+/**
+ * File: array_hash_map.js
+ * Created Time: 2022-12-26
+ * Author: Justin (xiefahit@gmail.com)
+ */
+
+/* Пара ключ-значение Number -> String */
+class Pair {
+    constructor(key, val) {
+        this.key = key;
+        this.val = val;
+    }
+}
+
+/* Хеш-таблица на основе массива */
+class ArrayHashMap {
+    #buckets;
+    constructor() {
+        // Инициализировать массив, содержащий 100 корзин
+        this.#buckets = new Array(100).fill(null);
+    }
+
+    /* Хеш-функция */
+    #hashFunc(key) {
+        return key % 100;
+    }
+
+    /* Операция поиска */
+    get(key) {
+        let index = this.#hashFunc(key);
+        let pair = this.#buckets[index];
+        if (pair === null) return null;
+        return pair.val;
+    }
+
+    /* Операция добавления */
+    set(key, val) {
+        let index = this.#hashFunc(key);
+        this.#buckets[index] = new Pair(key, val);
+    }
+
+    /* Операция удаления */
+    delete(key) {
+        let index = this.#hashFunc(key);
+        // Присвоить null, что означает удаление
+        this.#buckets[index] = null;
+    }
+
+    /* Получить все пары ключ-значение */
+    entries() {
+        let arr = [];
+        for (let i = 0; i < this.#buckets.length; i++) {
+            if (this.#buckets[i]) {
+                arr.push(this.#buckets[i]);
+            }
+        }
+        return arr;
+    }
+
+    /* Получить все ключи */
+    keys() {
+        let arr = [];
+        for (let i = 0; i < this.#buckets.length; i++) {
+            if (this.#buckets[i]) {
+                arr.push(this.#buckets[i].key);
+            }
+        }
+        return arr;
+    }
+
+    /* Получить все значения */
+    values() {
+        let arr = [];
+        for (let i = 0; i < this.#buckets.length; i++) {
+            if (this.#buckets[i]) {
+                arr.push(this.#buckets[i].val);
+            }
+        }
+        return arr;
+    }
+
+    /* Вывести хеш-таблицу */
+    print() {
+        let pairSet = this.entries();
+        for (const pair of pairSet) {
+            console.info(`${pair.key} -> ${pair.val}`);
+        }
+    }
+}
+
+/* Driver Code */
+/* Инициализация хеш-таблицы */
+const map = new ArrayHashMap();
+/* Операция добавления */
+// Добавить пару (key, value) в хеш-таблицу
+map.set(12836, 'Сяо Ха');
+map.set(15937, 'Сяо Ло');
+map.set(16750, 'Сяо Суань');
+map.set(13276, 'Сяо Фа');
+map.set(10583, 'Сяо Я');
+console.info('\nПосле добавления хеш-таблица имеет вид\nКлюч -> Значение');
+map.print();
+
+/* Операция поиска */
+// Ввести в хеш-таблицу ключ key и получить значение value
+let name = map.get(15937);
+console.info('\nПо номеру 15937 найдено имя ' + name);
+
+/* Операция удаления */
+// Удалить пару (key, value) из хеш-таблицы
+map.delete(10583);
+console.info('\nПосле удаления 10583 хеш-таблица имеет вид\nКлюч -> Значение');
+map.print();
+
+/* Обход хеш-таблицы */
+console.info('\nОтдельный обход пар ключ-значение');
+for (const pair of map.entries()) {
+    if (!pair) continue;
+    console.info(pair.key + ' -> ' + pair.val);
+}
+console.info('\nОтдельный обход ключей');
+for (const key of map.keys()) {
+    console.info(key);
+}
+console.info('\nОтдельный обход значений');
+for (const val of map.values()) {
+    console.info(val);
+}

ru/codes/javascript/chapter_hashing/hash_map.js

@@ -0,0 +1,44 @@
+/**
+ * File: hash_map.js
+ * Created Time: 2022-12-26
+ * Author: Justin (xiefahit@gmail.com)
+ */
+
+/* Driver Code */
+/* Инициализация хеш-таблицы */
+const map = new Map();
+
+/* Операция добавления */
+// Добавить пару (key, value) в хеш-таблицу
+map.set(12836, 'Сяо Ха');
+map.set(15937, 'Сяо Ло');
+map.set(16750, 'Сяо Суань');
+map.set(13276, 'Сяо Фа');
+map.set(10583, 'Сяо Я');
+console.info('\nПосле добавления хеш-таблица имеет вид\nКлюч -> Значение');
+console.info(map);
+
+/* Операция поиска */
+// Ввести в хеш-таблицу ключ key и получить значение value
+let name = map.get(15937);
+console.info('\nПо номеру 15937 найдено имя ' + name);
+
+/* Операция удаления */
+// Удалить пару (key, value) из хеш-таблицы
+map.delete(10583);
+console.info('\nПосле удаления 10583 хеш-таблица имеет вид\nКлюч -> Значение');
+console.info(map);
+
+/* Обход хеш-таблицы */
+console.info('\nОтдельный обход пар ключ-значение');
+for (const [k, v] of map.entries()) {
+    console.info(k + ' -> ' + v);
+}
+console.info('\nОтдельный обход ключей');
+for (const k of map.keys()) {
+    console.info(k);
+}
+console.info('\nОтдельный обход значений');
+for (const v of map.values()) {
+    console.info(v);
+}

ru/codes/javascript/chapter_hashing/hash_map_chaining.js

@@ -0,0 +1,142 @@
+/**
+ * File: hash_map_chaining.js
+ * Created Time: 2023-08-06
+ * Author: yuan0221 (yl1452491917@gmail.com)
+ */
+
+/* Пара ключ-значение Number -> String */
+class Pair {
+    constructor(key, val) {
+        this.key = key;
+        this.val = val;
+    }
+}
+
+/* Хеш-таблица с цепочками */
+class HashMapChaining {
+    #size; // Число пар ключ-значение
+    #capacity; // Вместимость хеш-таблицы
+    #loadThres; // Порог коэффициента загрузки для запуска расширения
+    #extendRatio; // Коэффициент расширения
+    #buckets; // Массив корзин
+
+    /* Конструктор */
+    constructor() {
+        this.#size = 0;
+        this.#capacity = 4;
+        this.#loadThres = 2.0 / 3.0;
+        this.#extendRatio = 2;
+        this.#buckets = new Array(this.#capacity).fill(null).map((x) => []);
+    }
+
+    /* Хеш-функция */
+    #hashFunc(key) {
+        return key % this.#capacity;
+    }
+
+    /* Коэффициент загрузки */
+    #loadFactor() {
+        return this.#size / this.#capacity;
+    }
+
+    /* Операция поиска */
+    get(key) {
+        const index = this.#hashFunc(key);
+        const bucket = this.#buckets[index];
+        // Обойти корзину; если найден key, вернуть соответствующее val
+        for (const pair of bucket) {
+            if (pair.key === key) {
+                return pair.val;
+            }
+        }
+        // Если key не найден, вернуть null
+        return null;
+    }
+
+    /* Операция добавления */
+    put(key, val) {
+        // Когда коэффициент загрузки превышает порог, выполнить расширение
+        if (this.#loadFactor() > this.#loadThres) {
+            this.#extend();
+        }
+        const index = this.#hashFunc(key);
+        const bucket = this.#buckets[index];
+        // Обойти корзину; если встретился указанный key, обновить соответствующее val и вернуть
+        for (const pair of bucket) {
+            if (pair.key === key) {
+                pair.val = val;
+                return;
+            }
+        }
+        // Если такого key нет, добавить пару ключ-значение в конец
+        const pair = new Pair(key, val);
+        bucket.push(pair);
+        this.#size++;
+    }
+
+    /* Операция удаления */
+    remove(key) {
+        const index = this.#hashFunc(key);
+        let bucket = this.#buckets[index];
+        // Обойти корзину и удалить из нее пару ключ-значение
+        for (let i = 0; i < bucket.length; i++) {
+            if (bucket[i].key === key) {
+                bucket.splice(i, 1);
+                this.#size--;
+                break;
+            }
+        }
+    }
+
+    /* Расширить хеш-таблицу */
+    #extend() {
+        // Временно сохранить исходную хеш-таблицу
+        const bucketsTmp = this.#buckets;
+        // Инициализация новой хеш-таблицы после расширения
+        this.#capacity *= this.#extendRatio;
+        this.#buckets = new Array(this.#capacity).fill(null).map((x) => []);
+        this.#size = 0;
+        // Перенести пары ключ-значение из исходной хеш-таблицы в новую
+        for (const bucket of bucketsTmp) {
+            for (const pair of bucket) {
+                this.put(pair.key, pair.val);
+            }
+        }
+    }
+
+    /* Вывести хеш-таблицу */
+    print() {
+        for (const bucket of this.#buckets) {
+            let res = [];
+            for (const pair of bucket) {
+                res.push(pair.key + ' -> ' + pair.val);
+            }
+            console.log(res);
+        }
+    }
+}
+
+/* Driver Code */
+/* Инициализация хеш-таблицы */
+const map = new HashMapChaining();
+
+/* Операция добавления */
+// Добавить пару (key, value) в хеш-таблицу
+map.put(12836, 'Сяо Ха');
+map.put(15937, 'Сяо Ло');
+map.put(16750, 'Сяо Суань');
+map.put(13276, 'Сяо Фа');
+map.put(10583, 'Сяо Я');
+console.log('\nПосле добавления хеш-таблица имеет вид\nКлюч -> Значение');
+map.print();
+
+/* Операция поиска */
+// Ввести в хеш-таблицу ключ key и получить значение value
+const name = map.get(13276);
+console.log('\nДля номера 13276 найдено имя ' + name);
+
+/* Операция удаления */
+// Удалить пару (key, value) из хеш-таблицы
+map.remove(12836);
+console.log('\nПосле удаления 12836 хеш-таблица имеет вид\nКлюч -> Значение');
+map.print();

ru/codes/javascript/chapter_hashing/hash_map_open_addressing.js

@@ -0,0 +1,177 @@
+/**
+ * File: hashMapOpenAddressing.js
+ * Created Time: 2023-06-13
+ * Author: yuan0221 (yl1452491917@gmail.com), krahets (krahets@163.com)
+ */
+
+/* Пара ключ-значение Number -> String */
+class Pair {
+    constructor(key, val) {
+        this.key = key;
+        this.val = val;
+    }
+}
+
+/* Хеш-таблица с открытой адресацией */
+class HashMapOpenAddressing {
+    #size; // Число пар ключ-значение
+    #capacity; // Вместимость хеш-таблицы
+    #loadThres; // Порог коэффициента загрузки для запуска расширения
+    #extendRatio; // Коэффициент расширения
+    #buckets; // Массив корзин
+    #TOMBSTONE; // Удалить метку
+
+    /* Конструктор */
+    constructor() {
+        this.#size = 0; // Число пар ключ-значение
+        this.#capacity = 4; // Вместимость хеш-таблицы
+        this.#loadThres = 2.0 / 3.0; // Порог коэффициента загрузки для запуска расширения
+        this.#extendRatio = 2; // Коэффициент расширения
+        this.#buckets = Array(this.#capacity).fill(null); // Массив корзин
+        this.#TOMBSTONE = new Pair(-1, '-1'); // Удалить метку
+    }
+
+    /* Хеш-функция */
+    #hashFunc(key) {
+        return key % this.#capacity;
+    }
+
+    /* Коэффициент загрузки */
+    #loadFactor() {
+        return this.#size / this.#capacity;
+    }
+
+    /* Найти индекс корзины, соответствующий key */
+    #findBucket(key) {
+        let index = this.#hashFunc(key);
+        let firstTombstone = -1;
+        // Выполнять линейное пробирование и завершить при встрече с пустой корзиной
+        while (this.#buckets[index] !== null) {
+            // Если встретился key, вернуть соответствующий индекс корзины
+            if (this.#buckets[index].key === key) {
+                // Если ранее встретилась метка удаления, переместить пару ключ-значение на этот индекс
+                if (firstTombstone !== -1) {
+                    this.#buckets[firstTombstone] = this.#buckets[index];
+                    this.#buckets[index] = this.#TOMBSTONE;
+                    return firstTombstone; // Вернуть индекс корзины после перемещения
+                }
+                return index; // Вернуть индекс корзины
+            }
+            // Записать первую встретившуюся метку удаления
+            if (
+                firstTombstone === -1 &&
+                this.#buckets[index] === this.#TOMBSTONE
+            ) {
+                firstTombstone = index;
+            }
+            // Вычислить индекс корзины; при выходе за конец вернуться к началу
+            index = (index + 1) % this.#capacity;
+        }
+        // Если key не существует, вернуть индекс точки добавления
+        return firstTombstone === -1 ? index : firstTombstone;
+    }
+
+    /* Операция поиска */
+    get(key) {
+        // Найти индекс корзины, соответствующий key
+        const index = this.#findBucket(key);
+        // Если пара ключ-значение найдена, вернуть соответствующее val
+        if (
+            this.#buckets[index] !== null &&
+            this.#buckets[index] !== this.#TOMBSTONE
+        ) {
+            return this.#buckets[index].val;
+        }
+        // Если пары ключ-значение не существует, вернуть null
+        return null;
+    }
+
+    /* Операция добавления */
+    put(key, val) {
+        // Когда коэффициент загрузки превышает порог, выполнить расширение
+        if (this.#loadFactor() > this.#loadThres) {
+            this.#extend();
+        }
+        // Найти индекс корзины, соответствующий key
+        const index = this.#findBucket(key);
+        // Если пара ключ-значение найдена, перезаписать val и вернуть
+        if (
+            this.#buckets[index] !== null &&
+            this.#buckets[index] !== this.#TOMBSTONE
+        ) {
+            this.#buckets[index].val = val;
+            return;
+        }
+        // Если пары ключ-значение нет, добавить ее
+        this.#buckets[index] = new Pair(key, val);
+        this.#size++;
+    }
+
+    /* Операция удаления */
+    remove(key) {
+        // Найти индекс корзины, соответствующий key
+        const index = this.#findBucket(key);
+        // Если пара ключ-значение найдена, заменить ее меткой удаления
+        if (
+            this.#buckets[index] !== null &&
+            this.#buckets[index] !== this.#TOMBSTONE
+        ) {
+            this.#buckets[index] = this.#TOMBSTONE;
+            this.#size--;
+        }
+    }
+
+    /* Расширить хеш-таблицу */
+    #extend() {
+        // Временно сохранить исходную хеш-таблицу
+        const bucketsTmp = this.#buckets;
+        // Инициализация новой хеш-таблицы после расширения
+        this.#capacity *= this.#extendRatio;
+        this.#buckets = Array(this.#capacity).fill(null);
+        this.#size = 0;
+        // Перенести пары ключ-значение из исходной хеш-таблицы в новую
+        for (const pair of bucketsTmp) {
+            if (pair !== null && pair !== this.#TOMBSTONE) {
+                this.put(pair.key, pair.val);
+            }
+        }
+    }
+
+    /* Вывести хеш-таблицу */
+    print() {
+        for (const pair of this.#buckets) {
+            if (pair === null) {
+                console.log('null');
+            } else if (pair === this.#TOMBSTONE) {
+                console.log('TOMBSTONE');
+            } else {
+                console.log(pair.key + ' -> ' + pair.val);
+            }
+        }
+    }
+}
+
+/* Driver Code */
+// Инициализация хеш-таблицы
+const hashmap = new HashMapOpenAddressing();
+
+// Операция добавления
+// Добавить пару (key, val) в хеш-таблицу
+hashmap.put(12836, 'Сяо Ха');
+hashmap.put(15937, 'Сяо Ло');
+hashmap.put(16750, 'Сяо Суань');
+hashmap.put(13276, 'Сяо Фа');
+hashmap.put(10583, 'Сяо Я');
+console.log('\nПосле добавления хеш-таблица имеет вид\nКлюч -> Значение');
+hashmap.print();
+
+// Операция поиска
+// Передать ключ key в хеш-таблицу и получить значение val
+const name = hashmap.get(13276);
+console.log('\nДля номера 13276 найдено имя ' + name);
+
+// Операция удаления
+// Удалить пару (key, val) из хеш-таблицы
+hashmap.remove(16750);
+console.log('\nПосле удаления 16750 хеш-таблица имеет вид\nКлюч -> Значение');
+hashmap.print();

ru/codes/javascript/chapter_hashing/simple_hash.js

@@ -0,0 +1,60 @@
+/**
+ * File: simple_hash.js
+ * Created Time: 2023-08-06
+ * Author: yuan0221 (yl1452491917@gmail.com)
+ */
+
+/* Аддитивное хеширование */
+function addHash(key) {
+    let hash = 0;
+    const MODULUS = 1000000007;
+    for (const c of key) {
+        hash = (hash + c.charCodeAt(0)) % MODULUS;
+    }
+    return hash;
+}
+
+/* Мультипликативное хеширование */
+function mulHash(key) {
+    let hash = 0;
+    const MODULUS = 1000000007;
+    for (const c of key) {
+        hash = (31 * hash + c.charCodeAt(0)) % MODULUS;
+    }
+    return hash;
+}
+
+/* XOR-хеширование */
+function xorHash(key) {
+    let hash = 0;
+    const MODULUS = 1000000007;
+    for (const c of key) {
+        hash ^= c.charCodeAt(0);
+    }
+    return hash % MODULUS;
+}
+
+/* Хеширование с циклическим сдвигом */
+function rotHash(key) {
+    let hash = 0;
+    const MODULUS = 1000000007;
+    for (const c of key) {
+        hash = ((hash << 4) ^ (hash >> 28) ^ c.charCodeAt(0)) % MODULUS;
+    }
+    return hash;
+}
+
+/* Driver Code */
+const key = 'Hello Algo';
+
+let hash = addHash(key);
+console.log('Хеш-сумма сложением = ' + hash);
+
+hash = mulHash(key);
+console.log('Хеш-сумма умножением = ' + hash);
+
+hash = xorHash(key);
+console.log('Хеш-сумма XOR = ' + hash);
+
+hash = rotHash(key);
+console.log('Хеш-сумма с циклическим сдвигом = ' + hash);

ru/codes/javascript/chapter_heap/my_heap.js

@@ -0,0 +1,158 @@
+/**
+ * File: my_heap.js
+ * Created Time: 2023-02-06
+ * Author: what-is-me (whatisme@outlook.jp)
+ */
+
+const { printHeap } = require('../modules/PrintUtil');
+
+/* Класс максимальной кучи */
+class MaxHeap {
+    #maxHeap;
+
+    /* Конструктор, создающий пустую кучу или строящий кучу по входному списку */
+    constructor(nums) {
+        // Добавить элементы списка в кучу без изменений
+        this.#maxHeap = nums === undefined ? [] : [...nums];
+        // Выполнить heapify для всех узлов, кроме листовых
+        for (let i = this.#parent(this.size() - 1); i >= 0; i--) {
+            this.#siftDown(i);
+        }
+    }
+
+    /* Получить индекс левого дочернего узла */
+    #left(i) {
+        return 2 * i + 1;
+    }
+
+    /* Получить индекс правого дочернего узла */
+    #right(i) {
+        return 2 * i + 2;
+    }
+
+    /* Получить индекс родительского узла */
+    #parent(i) {
+        return Math.floor((i - 1) / 2); // Округление вниз при делении
+    }
+
+    /* Поменять элементы местами */
+    #swap(i, j) {
+        const tmp = this.#maxHeap[i];
+        this.#maxHeap[i] = this.#maxHeap[j];
+        this.#maxHeap[j] = tmp;
+    }
+
+    /* Получение размера кучи */
+    size() {
+        return this.#maxHeap.length;
+    }
+
+    /* Проверка, пуста ли куча */
+    isEmpty() {
+        return this.size() === 0;
+    }
+
+    /* Доступ к элементу на вершине кучи */
+    peek() {
+        return this.#maxHeap[0];
+    }
+
+    /* Добавление элемента в кучу */
+    push(val) {
+        // Добавление узла
+        this.#maxHeap.push(val);
+        // Просеивание снизу вверх
+        this.#siftUp(this.size() - 1);
+    }
+
+    /* Начиная с узла i, выполнить просеивание снизу вверх */
+    #siftUp(i) {
+        while (true) {
+            // Получение родительского узла для узла i
+            const p = this.#parent(i);
+            // Завершить heapify, когда «корневой узел уже пройден» или «узел не требует исправления»
+            if (p < 0 || this.#maxHeap[i] <= this.#maxHeap[p]) break;
+            // Поменять два узла местами
+            this.#swap(i, p);
+            // Циклическое просеивание вверх
+            i = p;
+        }
+    }
+
+    /* Извлечение элемента из кучи */
+    pop() {
+        // Обработка пустого случая
+        if (this.isEmpty()) throw new Error('куча пуста');
+        // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)
+        this.#swap(0, this.size() - 1);
+        // Удаление узла
+        const val = this.#maxHeap.pop();
+        // Просеивание сверху вниз
+        this.#siftDown(0);
+        // Вернуть элемент с вершины кучи
+        return val;
+    }
+
+    /* Начиная с узла i, выполнить просеивание сверху вниз */
+    #siftDown(i) {
+        while (true) {
+            // Определить узел с максимальным значением среди i, l и r и обозначить его как ma
+            const l = this.#left(i),
+                r = this.#right(i);
+            let ma = i;
+            if (l < this.size() && this.#maxHeap[l] > this.#maxHeap[ma]) ma = l;
+            if (r < this.size() && this.#maxHeap[r] > this.#maxHeap[ma]) ma = r;
+            // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти
+            if (ma === i) break;
+            // Поменять два узла местами
+            this.#swap(i, ma);
+            // Циклическое просеивание вниз
+            i = ma;
+        }
+    }
+
+    /* Вывести кучу (двоичное дерево) */
+    print() {
+        printHeap(this.#maxHeap);
+    }
+
+    /* Извлечь элементы из кучи */
+    getMaxHeap() {
+        return this.#maxHeap;
+    }
+}
+
+/* Driver Code */
+if (require.main === module) {
+    /* Инициализация максимальной кучи */
+    const maxHeap = new MaxHeap([9, 8, 6, 6, 7, 5, 2, 1, 4, 3, 6, 2]);
+    console.log('\nПосле построения кучи из входного списка');
+    maxHeap.print();
+
+    /* Получение элемента с вершины кучи */
+    let peek = maxHeap.peek();
+    console.log(`\nЭлемент на вершине кучи = ${peek}`);
+
+    /* Добавление элемента в кучу */
+    let val = 7;
+    maxHeap.push(val);
+    console.log(`\nПосле добавления элемента ${val} в кучу`);
+    maxHeap.print();
+
+    /* Извлечение элемента с вершины кучи */
+    peek = maxHeap.pop();
+    console.log(`\nПосле извлечения элемента вершины кучи ${peek}`);
+    maxHeap.print();
+
+    /* Получение размера кучи */
+    let size = maxHeap.size();
+    console.log(`\nКоличество элементов в куче = ${size}`);
+
+    /* Проверка, пуста ли куча */
+    let isEmpty = maxHeap.isEmpty();
+    console.log(`\nПуста ли куча: ${isEmpty}`);
+}
+
+module.exports = {
+    MaxHeap,
+};

ru/codes/javascript/chapter_heap/top_k.js

@@ -0,0 +1,58 @@
+/**
+ * File: top_k.js
+ * Created Time: 2023-08-13
+ * Author: Justin (xiefahit@gmail.com)
+ */
+
+const { MaxHeap } = require('./my_heap');
+
+/* Добавление элемента в кучу */
+function pushMinHeap(maxHeap, val) {
+    // Инвертировать знак элемента
+    maxHeap.push(-val);
+}
+
+/* Извлечение элемента из кучи */
+function popMinHeap(maxHeap) {
+    // Инвертировать знак элемента
+    return -maxHeap.pop();
+}
+
+/* Доступ к элементу на вершине кучи */
+function peekMinHeap(maxHeap) {
+    // Инвертировать знак элемента
+    return -maxHeap.peek();
+}
+
+/* Извлечь элементы из кучи */
+function getMinHeap(maxHeap) {
+    // Инвертировать знак элемента
+    return maxHeap.getMaxHeap().map((num) => -num);
+}
+
+/* Найти k наибольших элементов массива с помощью кучи */
+function topKHeap(nums, k) {
+    // Инициализация минимальной кучи
+    // Обратите внимание: мы инвертируем все элементы кучи, чтобы с помощью максимальной кучи имитировать минимальную
+    const maxHeap = new MaxHeap([]);
+    // Поместить первые k элементов массива в кучу
+    for (let i = 0; i < k; i++) {
+        pushMinHeap(maxHeap, nums[i]);
+    }
+    // Начиная с элемента k+1, поддерживать длину кучи равной k
+    for (let i = k; i < nums.length; i++) {
+        // Если текущий элемент больше элемента на вершине кучи, извлечь вершину кучи и добавить текущий элемент в кучу
+        if (nums[i] > peekMinHeap(maxHeap)) {
+            popMinHeap(maxHeap);
+            pushMinHeap(maxHeap, nums[i]);
+        }
+    }
+    // Вернуть элементы кучи
+    return getMinHeap(maxHeap);
+}
+
+/* Driver Code */
+const nums = [1, 7, 6, 3, 2];
+const k = 3;
+const res = topKHeap(nums, k);
+console.log(`Наибольшие ${k} элементов`, res);

ru/codes/javascript/chapter_searching/binary_search.js

@@ -0,0 +1,60 @@
+/**
+ * File: binary_search.js
+ * Created Time: 2022-12-22
+ * Author: JoseHung (szhong@link.cuhk.edu.hk)
+ */
+
+/* Бинарный поиск (двусторонне замкнутый интервал) */
+function binarySearch(nums, target) {
+    // Инициализировать двусторонне замкнутый интервал [0, n-1], то есть i и j указывают на первый и последний элементы массива соответственно
+    let i = 0,
+        j = nums.length - 1;
+    // Цикл завершается, когда диапазон поиска пуст (при i > j диапазон пуст)
+    while (i <= j) {
+        // Вычислить индекс середины m, используя parseInt() для округления вниз
+        const m = parseInt(i + (j - i) / 2);
+        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;
+}
+
+/* Бинарный поиск (лево замкнутый, право открытый интервал) */
+function binarySearchLCRO(nums, target) {
+    // Инициализировать лево замкнутый, право открытый интервал [0, n), то есть i и j указывают на первый элемент массива и позицию сразу за последним элементом соответственно
+    let i = 0,
+        j = nums.length;
+    // Цикл завершается, когда диапазон поиска пуст (при i = j диапазон пуст)
+    while (i < j) {
+        // Вычислить индекс середины m, используя parseInt() для округления вниз
+        const m = parseInt(i + (j - i) / 2);
+        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 */
+const target = 6;
+const nums = [1, 3, 6, 8, 12, 15, 23, 26, 31, 35];
+
+/* Бинарный поиск (двусторонне замкнутый интервал) */
+let index = binarySearch(nums, target);
+console.log('Индекс целевого элемента 6 = ' + index);
+
+/* Бинарный поиск (лево замкнутый, право открытый интервал) */
+index = binarySearchLCRO(nums, target);
+console.log('Индекс целевого элемента 6 = ' + index);

ru/codes/javascript/chapter_searching/binary_search_edge.js

@@ -0,0 +1,45 @@
+/**
+ * File: binary_search_edge.js
+ * Created Time: 2023-08-22
+ * Author: Gaofer Chou (gaofer-chou@qq.com)
+ */
+
+const { binarySearchInsertion } = require('./binary_search_insertion.js');
+
+/* Бинарный поиск самого левого target */
+function binarySearchLeftEdge(nums, target) {
+    // Эквивалентно поиску точки вставки target
+    const i = binarySearchInsertion(nums, target);
+    // target не найден, вернуть -1
+    if (i === nums.length || nums[i] !== target) {
+        return -1;
+    }
+    // Найти target и вернуть индекс i
+    return i;
+}
+
+/* Бинарный поиск самого правого target */
+function binarySearchRightEdge(nums, target) {
+    // Преобразовать задачу в поиск самого левого target + 1
+    const i = binarySearchInsertion(nums, target + 1);
+    // j указывает на самый правый target, а i — на первый элемент больше target
+    const j = i - 1;
+    // target не найден, вернуть -1
+    if (j === -1 || nums[j] !== target) {
+        return -1;
+    }
+    // Найти target и вернуть индекс j
+    return j;
+}
+
+/* Driver Code */
+// Массив с повторяющимися элементами
+const nums = [1, 3, 6, 6, 6, 6, 6, 10, 12, 15];
+console.log('\nМассив nums = ' + nums);
+// Бинарный поиск левой и правой границы
+for (const target of [6, 7]) {
+    let index = binarySearchLeftEdge(nums, target);
+    console.log('Индекс самого левого элемента ' + target + ' равен ' + index);
+    index = binarySearchRightEdge(nums, target);
+    console.log('Индекс самого правого элемента ' + target + ' равен ' + index);
+}

ru/codes/javascript/chapter_searching/binary_search_insertion.js

@@ -0,0 +1,64 @@
+/**
+ * File: binary_search_insertion.js
+ * Created Time: 2023-08-22
+ * Author: Gaofer Chou (gaofer-chou@qq.com)
+ */
+
+/* Бинарный поиск точки вставки (без повторяющихся элементов) */
+function binarySearchInsertionSimple(nums, target) {
+    let i = 0,
+        j = nums.length - 1; // Инициализировать двусторонне замкнутый интервал [0, n-1]
+    while (i <= j) {
+        const m = Math.floor(i + (j - i) / 2); // Вычислить индекс середины m, используя Math.floor() для округления вниз
+        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;
+}
+
+/* Бинарный поиск точки вставки (с повторяющимися элементами) */
+function binarySearchInsertion(nums, target) {
+    let i = 0,
+        j = nums.length - 1; // Инициализировать двусторонне замкнутый интервал [0, n-1]
+    while (i <= j) {
+        const m = Math.floor(i + (j - i) / 2); // Вычислить индекс середины m, используя Math.floor() для округления вниз
+        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 */
+// Массив без повторяющихся элементов
+let nums = [1, 3, 6, 8, 12, 15, 23, 26, 31, 35];
+console.log('\nМассив nums = ' + nums);
+// Бинарный поиск точки вставки
+for (const target of [6, 9]) {
+    const index = binarySearchInsertionSimple(nums, target);
+    console.log('Индекс позиции вставки элемента ' + target + ' равен ' + index);
+}
+
+// Массив с повторяющимися элементами
+nums = [1, 3, 6, 6, 6, 6, 6, 10, 12, 15];
+console.log('\nМассив nums = ' + nums);
+// Бинарный поиск точки вставки
+for (const target of [2, 6, 20]) {
+    const index = binarySearchInsertion(nums, target);
+    console.log('Индекс позиции вставки элемента ' + target + ' равен ' + index);
+}
+
+module.exports = {
+    binarySearchInsertion,
+};

ru/codes/javascript/chapter_searching/hashing_search.js

@@ -0,0 +1,45 @@
+/**
+ * File: hashing_search.js
+ * Created Time: 2022-12-29
+ * Author: Zhuo Qinyue (1403450829@qq.com)
+ */
+
+const { arrToLinkedList } = require('../modules/ListNode');
+
+/* Хеш-поиск (массив) */
+function hashingSearchArray(map, target) {
+    // key хеш-таблицы: целевой элемент, value: индекс
+    // Если такого key нет в хеш-таблице, вернуть -1
+    return map.has(target) ? map.get(target) : -1;
+}
+
+/* Хеш-поиск (связный список) */
+function hashingSearchLinkedList(map, target) {
+    // key хеш-таблицы: значение целевого узла, value: объект узла
+    // Если такого key нет в хеш-таблице, вернуть null
+    return map.has(target) ? map.get(target) : null;
+}
+
+/* Driver Code */
+const target = 3;
+
+/* Хеш-поиск (массив) */
+const nums = [1, 5, 3, 2, 4, 7, 5, 9, 10, 8];
+// Инициализация хеш-таблицы
+const map = new Map();
+for (let i = 0; i < nums.length; i++) {
+    map.set(nums[i], i); // key: элемент, value: индекс
+}
+const index = hashingSearchArray(map, target);
+console.log('Индекс целевого элемента 3 = ' + index);
+
+/* Хеш-поиск (связный список) */
+let head = arrToLinkedList(nums);
+// Инициализация хеш-таблицы
+const map1 = new Map();
+while (head != null) {
+    map1.set(head.val, head); // key: значение узла, value: узел
+    head = head.next;
+}
+const node = hashingSearchLinkedList(map1, target);
+console.log('Объект узла со значением 3 =', node);

ru/codes/javascript/chapter_searching/linear_search.js

@@ -0,0 +1,47 @@
+/**
+ * File: linear_search.js
+ * Created Time: 2022-12-22
+ * Author: JoseHung (szhong@link.cuhk.edu.hk)
+ */
+
+const { ListNode, arrToLinkedList } = require('../modules/ListNode');
+
+/* Линейный поиск (массив) */
+function linearSearchArray(nums, target) {
+    // Обход массива
+    for (let i = 0; i < nums.length; i++) {
+        // Целевой элемент найден, вернуть его индекс
+        if (nums[i] === target) {
+            return i;
+        }
+    }
+    // Целевой элемент не найден, вернуть -1
+    return -1;
+}
+
+/* Линейный поиск (связный список) */
+function linearSearchLinkedList(head, target) {
+    // Обойти связный список
+    while (head) {
+        // Найти целевой узел и вернуть его
+        if (head.val === target) {
+            return head;
+        }
+        head = head.next;
+    }
+    // Целевой узел не найден, вернуть null
+    return null;
+}
+
+/* Driver Code */
+const target = 3;
+
+/* Выполнить линейный поиск в массиве */
+const nums = [1, 5, 3, 2, 4, 7, 5, 9, 10, 8];
+const index = linearSearchArray(nums, target);
+console.log('Индекс целевого элемента 3 = ' + index);
+
+/* Выполнить линейный поиск в связном списке */
+const head = arrToLinkedList(nums);
+const node = linearSearchLinkedList(head, target);
+console.log('Объект узла со значением 3 = ', node);

ru/codes/javascript/chapter_searching/two_sum.js

@@ -0,0 +1,46 @@
+/**
+ * File: two_sum.js
+ * Created Time: 2022-12-15
+ * Author: gyt95 (gytkwan@gmail.com)
+ */
+
+/* Метод 1: полный перебор */
+function twoSumBruteForce(nums, target) {
+    const n = nums.length;
+    // Два вложенных цикла, временная сложность O(n^2)
+    for (let i = 0; i < n; i++) {
+        for (let j = i + 1; j < n; j++) {
+            if (nums[i] + nums[j] === target) {
+                return [i, j];
+            }
+        }
+    }
+    return [];
+}
+
+/* Метод 2: вспомогательная хеш-таблица */
+function twoSumHashTable(nums, target) {
+    // Вспомогательная хеш-таблица, пространственная сложность O(n)
+    let m = {};
+    // Один цикл, временная сложность O(n)
+    for (let i = 0; i < nums.length; i++) {
+        if (m[target - nums[i]] !== undefined) {
+            return [m[target - nums[i]], i];
+        } else {
+            m[nums[i]] = i;
+        }
+    }
+    return [];
+}
+
+/* Driver Code */
+// Метод 1
+const nums = [2, 7, 11, 15],
+    target = 13;
+
+let res = twoSumBruteForce(nums, target);
+console.log('Результат метода 1 res = ', res);
+
+// Метод 2
+res = twoSumHashTable(nums, target);
+console.log('Результат метода 2 res = ', res);

ru/codes/javascript/chapter_sorting/bubble_sort.js

@@ -0,0 +1,49 @@
+/**
+ * File: bubble_sort.js
+ * Created Time: 2022-12-01
+ * Author: IsChristina (christinaxia77@foxmail.com)
+ */
+
+/* Пузырьковая сортировка */
+function bubbleSort(nums) {
+    // Внешний цикл: неотсортированный диапазон [0, i]
+    for (let i = nums.length - 1; i > 0; i--) {
+        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
+        for (let j = 0; j < i; j++) {
+            if (nums[j] > nums[j + 1]) {
+                // Поменять местами nums[j] и nums[j + 1]
+                let tmp = nums[j];
+                nums[j] = nums[j + 1];
+                nums[j + 1] = tmp;
+            }
+        }
+    }
+}
+
+/* Пузырьковая сортировка (оптимизация флагом) */
+function bubbleSortWithFlag(nums) {
+    // Внешний цикл: неотсортированный диапазон [0, i]
+    for (let i = nums.length - 1; i > 0; i--) {
+        let flag = false; // Инициализировать флаг
+        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
+        for (let j = 0; j < i; j++) {
+            if (nums[j] > nums[j + 1]) {
+                // Поменять местами nums[j] и nums[j + 1]
+                let tmp = nums[j];
+                nums[j] = nums[j + 1];
+                nums[j + 1] = tmp;
+                flag = true; // Записать обмен элементов
+            }
+        }
+        if (!flag) break; // На этой итерации «всплытия» не было ни одного обмена, сразу выйти
+    }
+}
+
+/* Driver Code */
+const nums = [4, 1, 3, 1, 5, 2];
+bubbleSort(nums);
+console.log('После пузырьковой сортировки nums =', nums);
+
+const nums1 = [4, 1, 3, 1, 5, 2];
+bubbleSortWithFlag(nums1);
+console.log('После пузырьковой сортировки nums =', nums1);

ru/codes/javascript/chapter_sorting/bucket_sort.js

@@ -0,0 +1,39 @@
+/**
+ * File: bucket_sort.js
+ * Created Time: 2023-04-08
+ * Author: Justin (xiefahit@gmail.com)
+ */
+
+/* Сортировка корзинами */
+function bucketSort(nums) {
+    // Инициализировать k = n/2 корзин, предполагая распределение 2 элементов в каждую корзину
+    const k = nums.length / 2;
+    const buckets = [];
+    for (let i = 0; i < k; i++) {
+        buckets.push([]);
+    }
+    // 1. Распределить элементы массива по корзинам
+    for (const num of nums) {
+        // Входные данные лежат в диапазоне [0, 1); использовать num * k для отображения в диапазон индексов [0, k-1]
+        const i = Math.floor(num * k);
+        // Добавить num в корзину i
+        buckets[i].push(num);
+    }
+    // 2. Выполнить сортировку внутри каждой корзины
+    for (const bucket of buckets) {
+        // Использовать встроенную функцию сортировки; ее также можно заменить другим алгоритмом сортировки
+        bucket.sort((a, b) => a - b);
+    }
+    // 3. Обойти корзины и объединить результаты
+    let i = 0;
+    for (const bucket of buckets) {
+        for (const num of bucket) {
+            nums[i++] = num;
+        }
+    }
+}
+
+/* Driver Code */
+const nums = [0.49, 0.96, 0.82, 0.09, 0.57, 0.43, 0.91, 0.75, 0.15, 0.37];
+bucketSort(nums);
+console.log('После сортировки корзинами nums =', nums);

ru/codes/javascript/chapter_sorting/counting_sort.js

@@ -0,0 +1,65 @@
+/**
+ * File: counting_sort.js
+ * Created Time: 2023-04-08
+ * Author: Justin (xiefahit@gmail.com)
+ */
+
+/* Сортировка подсчетом */
+// Простая реализация, не подходит для сортировки объектов
+function countingSortNaive(nums) {
+    // 1. Найти максимальный элемент массива m
+    let m = Math.max(...nums);
+    // 2. Подсчитать число появлений каждой цифры
+    // counter[num] обозначает число появлений num
+    const counter = new Array(m + 1).fill(0);
+    for (const num of nums) {
+        counter[num]++;
+    }
+    // 3. Обойти counter и заполнить исходный массив nums элементами
+    let i = 0;
+    for (let num = 0; num < m + 1; num++) {
+        for (let j = 0; j < counter[num]; j++, i++) {
+            nums[i] = num;
+        }
+    }
+}
+
+/* Сортировка подсчетом */
+// Полная реализация, позволяет сортировать объекты и является стабильной сортировкой
+function countingSort(nums) {
+    // 1. Найти максимальный элемент массива m
+    let m = Math.max(...nums);
+    // 2. Подсчитать число появлений каждой цифры
+    // counter[num] обозначает число появлений num
+    const counter = new Array(m + 1).fill(0);
+    for (const num of nums) {
+        counter[num]++;
+    }
+    // 3. Вычислить префиксные суммы counter и преобразовать «число появлений» в «конечный индекс»
+    // То есть counter[num]-1 — это индекс последнего появления num в res
+    for (let i = 0; i < m; i++) {
+        counter[i + 1] += counter[i];
+    }
+    // 4. Обойти nums в обратном порядке и поместить элементы в результирующий массив res
+    // Инициализировать массив res для хранения результата
+    const n = nums.length;
+    const res = new Array(n);
+    for (let i = n - 1; i >= 0; i--) {
+        const num = nums[i];
+        res[counter[num] - 1] = num; // Поместить num по соответствующему индексу
+        counter[num]--; // Уменьшить префиксную сумму на 1, чтобы получить индекс следующего размещения num
+    }
+    // Перезаписать исходный массив nums массивом результата res
+    for (let i = 0; i < n; i++) {
+        nums[i] = res[i];
+    }
+}
+
+/* Driver Code */
+const nums = [1, 0, 1, 2, 0, 4, 0, 2, 2, 4];
+countingSortNaive(nums);
+console.log('После сортировки подсчетом (объекты не поддерживаются) nums =', nums);
+
+const nums1 = [1, 0, 1, 2, 0, 4, 0, 2, 2, 4];
+countingSort(nums1);
+console.log('После сортировки подсчетом nums1 =', nums1);

ru/codes/javascript/chapter_sorting/heap_sort.js

@@ -0,0 +1,49 @@
+/**
+ * File: heap_sort.js
+ * Created Time: 2023-06-04
+ * Author: Justin (xiefahit@gmail.com)
+ */
+
+/* Длина кучи равна n; начиная с узла i, выполнить просеивание сверху вниз */
+function siftDown(nums, n, i) {
+    while (true) {
+        // Определить узел с максимальным значением среди i, l и r и обозначить его как ma
+        let l = 2 * i + 1;
+        let r = 2 * i + 2;
+        let 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;
+        }
+        // Поменять два узла местами
+        [nums[i], nums[ma]] = [nums[ma], nums[i]];
+        // Циклическое просеивание вниз
+        i = ma;
+    }
+}
+
+/* Сортировка кучей */
+function heapSort(nums) {
+    // Построение кучи: выполнить heapify для всех узлов, кроме листовых
+    for (let i = Math.floor(nums.length / 2) - 1; i >= 0; i--) {
+        siftDown(nums, nums.length, i);
+    }
+    // Извлекать максимальный элемент из кучи в течение n-1 итераций
+    for (let i = nums.length - 1; i > 0; i--) {
+        // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)
+        [nums[0], nums[i]] = [nums[i], nums[0]];
+        // Начиная с корневого узла, выполнить просеивание сверху вниз
+        siftDown(nums, i, 0);
+    }
+}
+
+/* Driver Code */
+const nums = [4, 1, 3, 1, 5, 2];
+heapSort(nums);
+console.log('После сортировки кучей nums =', nums);

ru/codes/javascript/chapter_sorting/insertion_sort.js

@@ -0,0 +1,25 @@
+/**
+ * File: insertion_sort.js
+ * Created Time: 2022-12-01
+ * Author: IsChristina (christinaxia77@foxmail.com)
+ */
+
+/* Сортировка вставками */
+function insertionSort(nums) {
+    // Внешний цикл: отсортированный диапазон [0, i-1]
+    for (let i = 1; i < nums.length; i++) {
+        let 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 */
+const nums = [4, 1, 3, 1, 5, 2];
+insertionSort(nums);
+console.log('После сортировки вставками nums =', nums);

ru/codes/javascript/chapter_sorting/merge_sort.js

@@ -0,0 +1,52 @@
+/**
+ * File: merge_sort.js
+ * Created Time: 2022-12-01
+ * Author: IsChristina (christinaxia77@foxmail.com)
+ */
+
+/* Объединить левый и правый подмассивы */
+function merge(nums, left, mid, right) {
+    // Диапазон левого подмассива: [left, mid], диапазон правого подмассива: [mid+1, right]
+    // Создать временный массив tmp для хранения результата слияния
+    const tmp = new Array(right - left + 1);
+    // Инициализировать начальные индексы левого и правого подмассивов
+    let i = left,
+        j = mid + 1,
+        k = 0;
+    // Пока в левом и правом подмассивах еще есть элементы, сравнивать их и копировать меньший во временный массив
+    while (i <= mid && j <= right) {
+        if (nums[i] <= nums[j]) {
+            tmp[k++] = nums[i++];
+        } else {
+            tmp[k++] = nums[j++];
+        }
+    }
+    // Скопировать оставшиеся элементы левого и правого подмассивов во временный массив
+    while (i <= mid) {
+        tmp[k++] = nums[i++];
+    }
+    while (j <= right) {
+        tmp[k++] = nums[j++];
+    }
+    // Скопировать элементы временного массива tmp обратно в соответствующий диапазон исходного массива nums
+    for (k = 0; k < tmp.length; k++) {
+        nums[left + k] = tmp[k];
+    }
+}
+
+/* Сортировка слиянием */
+function mergeSort(nums, left, right) {
+    // Условие завершения
+    if (left >= right) return; // Завершить рекурсию, когда длина подмассива равна 1
+    // Этап разбиения
+    let mid = Math.floor(left + (right - left) / 2); // Вычислить середину
+    mergeSort(nums, left, mid); // Рекурсивно обработать левый подмассив
+    mergeSort(nums, mid + 1, right); // Рекурсивно обработать правый подмассив
+    // Этап слияния
+    merge(nums, left, mid, right);
+}
+
+/* Driver Code */
+const nums = [7, 3, 2, 6, 0, 1, 5, 4];
+mergeSort(nums, 0, nums.length - 1);
+console.log('После сортировки слиянием nums =', nums);

ru/codes/javascript/chapter_sorting/quick_sort.js

@@ -0,0 +1,161 @@
+/**
+ * File: quick_sort.js
+ * Created Time: 2022-12-01
+ * Author: IsChristina (christinaxia77@foxmail.com)
+ */
+
+/* Класс быстрой сортировки */
+class QuickSort {
+    /* Обмен элементов */
+    swap(nums, i, j) {
+        let tmp = nums[i];
+        nums[i] = nums[j];
+        nums[j] = tmp;
+    }
+
+    /* Разбиение с опорными указателями */
+    partition(nums, left, right) {
+        // Взять nums[left] в качестве опорного элемента
+        let i = left,
+            j = right;
+        while (i < j) {
+            while (i < j && nums[j] >= nums[left]) {
+                j -= 1; // Идти справа налево в поисках первого элемента меньше опорного
+            }
+            while (i < j && nums[i] <= nums[left]) {
+                i += 1; // Идти слева направо в поисках первого элемента больше опорного
+            }
+            // Обмен элементов
+            this.swap(nums, i, j); // Поменять эти два элемента местами
+        }
+        this.swap(nums, i, left); // Переместить опорный элемент на границу двух подмассивов
+        return i; // Вернуть индекс опорного элемента
+    }
+
+    /* Быстрая сортировка */
+    quickSort(nums, left, right) {
+        // Завершить рекурсию, когда длина подмассива равна 1
+        if (left >= right) return;
+        // Разбиение с опорными указателями
+        const pivot = this.partition(nums, left, right);
+        // Рекурсивно обработать левый и правый подмассивы
+        this.quickSort(nums, left, pivot - 1);
+        this.quickSort(nums, pivot + 1, right);
+    }
+}
+
+/* Класс быстрой сортировки (оптимизация медианным опорным элементом) */
+class QuickSortMedian {
+    /* Обмен элементов */
+    swap(nums, i, j) {
+        let tmp = nums[i];
+        nums[i] = nums[j];
+        nums[j] = tmp;
+    }
+
+    /* Выбрать медиану из трех кандидатов */
+    medianThree(nums, left, mid, right) {
+        let l = nums[left],
+            m = nums[mid],
+            r = nums[right];
+        // m находится между l и r
+        if ((l <= m && m <= r) || (r <= m && m <= l)) return mid;
+        // l находится между m и r
+        if ((m <= l && l <= r) || (r <= l && l <= m)) return left;
+        return right;
+    }
+
+    /* Разбиение с опорными указателями (медиана трех) */
+    partition(nums, left, right) {
+        // Выбрать медиану из трех кандидатов
+        let med = this.medianThree(
+            nums,
+            left,
+            Math.floor((left + right) / 2),
+            right
+        );
+        // Переместить медиану в крайний левый элемент массива
+        this.swap(nums, left, med);
+        // Взять nums[left] в качестве опорного элемента
+        let i = left,
+            j = right;
+        while (i < j) {
+            while (i < j && nums[j] >= nums[left]) j--; // Идти справа налево в поисках первого элемента меньше опорного
+            while (i < j && nums[i] <= nums[left]) i++; // Идти слева направо в поисках первого элемента больше опорного
+            this.swap(nums, i, j); // Поменять эти два элемента местами
+        }
+        this.swap(nums, i, left); // Переместить опорный элемент на границу двух подмассивов
+        return i; // Вернуть индекс опорного элемента
+    }
+
+    /* Быстрая сортировка */
+    quickSort(nums, left, right) {
+        // Завершить рекурсию, когда длина подмассива равна 1
+        if (left >= right) return;
+        // Разбиение с опорными указателями
+        const pivot = this.partition(nums, left, right);
+        // Рекурсивно обработать левый и правый подмассивы
+        this.quickSort(nums, left, pivot - 1);
+        this.quickSort(nums, pivot + 1, right);
+    }
+}
+
+/* Класс быстрой сортировки (оптимизация глубины рекурсии) */
+class QuickSortTailCall {
+    /* Обмен элементов */
+    swap(nums, i, j) {
+        let tmp = nums[i];
+        nums[i] = nums[j];
+        nums[j] = tmp;
+    }
+
+    /* Разбиение с опорными указателями */
+    partition(nums, left, right) {
+        // Взять nums[left] в качестве опорного элемента
+        let i = left,
+            j = right;
+        while (i < j) {
+            while (i < j && nums[j] >= nums[left]) j--; // Идти справа налево в поисках первого элемента меньше опорного
+            while (i < j && nums[i] <= nums[left]) i++; // Идти слева направо в поисках первого элемента больше опорного
+            this.swap(nums, i, j); // Поменять эти два элемента местами
+        }
+        this.swap(nums, i, left); // Переместить опорный элемент на границу двух подмассивов
+        return i; // Вернуть индекс опорного элемента
+    }
+
+    /* Быстрая сортировка (оптимизация глубины рекурсии) */
+    quickSort(nums, left, right) {
+        // Завершить, когда длина подмассива равна 1
+        while (left < right) {
+            // Операция разбиения с опорными указателями
+            let pivot = this.partition(nums, left, right);
+            // Выполнить быструю сортировку для более короткого из двух подмассивов
+            if (pivot - left < right - pivot) {
+                this.quickSort(nums, left, pivot - 1); // Рекурсивно отсортировать левый подмассив
+                left = pivot + 1; // Оставшийся неотсортированный диапазон: [pivot + 1, right]
+            } else {
+                this.quickSort(nums, pivot + 1, right); // Рекурсивно отсортировать правый подмассив
+                right = pivot - 1; // Оставшийся неотсортированный диапазон: [left, pivot - 1]
+            }
+        }
+    }
+}
+
+/* Driver Code */
+/* Быстрая сортировка */
+const nums = [2, 4, 1, 0, 3, 5];
+const quickSort = new QuickSort();
+quickSort.quickSort(nums, 0, nums.length - 1);
+console.log('После быстрой сортировки nums =', nums);
+
+/* Быстрая сортировка (оптимизация медианным опорным элементом) */
+const nums1 = [2, 4, 1, 0, 3, 5];
+const quickSortMedian = new QuickSortMedian();
+quickSortMedian.quickSort(nums1, 0, nums1.length - 1);
+console.log('После быстрой сортировки (оптимизация медианным опорным элементом) nums =', nums1);
+
+/* Быстрая сортировка (оптимизация глубины рекурсии) */
+const nums2 = [2, 4, 1, 0, 3, 5];
+const quickSortTailCall = new QuickSortTailCall();
+quickSortTailCall.quickSort(nums2, 0, nums2.length - 1);
+console.log('После быстрой сортировки (оптимизация глубины рекурсии) nums =', nums2);

ru/codes/javascript/chapter_sorting/radix_sort.js

@@ -0,0 +1,61 @@
+/**
+ * File: radix_sort.js
+ * Created Time: 2023-04-08
+ * Author: Justin (xiefahit@gmail.com)
+ */
+
+/* Получить k-й разряд элемента num, где exp = 10^(k-1) */
+function digit(num, exp) {
+    // Передача exp вместо k позволяет избежать повторного дорогостоящего вычисления степени
+    return Math.floor(num / exp) % 10;
+}
+
+/* Сортировка подсчетом (сортировка по k-му разряду nums) */
+function countingSortDigit(nums, exp) {
+    // Разряды десятичной системы лежат в диапазоне 0~9, поэтому нужен массив корзин длины 10
+    const counter = new Array(10).fill(0);
+    const n = nums.length;
+    // Подсчитать число появлений каждой цифры от 0 до 9
+    for (let i = 0; i < n; i++) {
+        const d = digit(nums[i], exp); // Получить k-й разряд nums[i], обозначив его как d
+        counter[d]++; // Подсчитать число появлений цифры d
+    }
+    // Вычислить префиксные суммы и преобразовать «число появлений» в «индекс массива»
+    for (let i = 1; i < 10; i++) {
+        counter[i] += counter[i - 1];
+    }
+    // Выполняя обратный проход, заполнить res элементами по статистике в корзинах
+    const res = new Array(n).fill(0);
+    for (let i = n - 1; i >= 0; i--) {
+        const d = digit(nums[i], exp);
+        const j = counter[d] - 1; // Получить индекс j цифры d в массиве
+        res[j] = nums[i]; // Поместить текущий элемент по индексу j
+        counter[d]--; // Уменьшить количество d на 1
+    }
+    // Перезаписать исходный массив nums результатом
+    for (let i = 0; i < n; i++) {
+        nums[i] = res[i];
+    }
+}
+
+/* Поразрядная сортировка */
+function radixSort(nums) {
+    // Получить максимальный элемент массива, чтобы определить максимальное число разрядов
+    let m = Math.max(... nums);
+    // Проходить разряды от младшего к старшему
+    for (let exp = 1; exp <= m; exp *= 10) {
+        // Выполнить сортировку подсчетом по k-му разряду элементов массива
+        // k = 1 -> exp = 1
+        // k = 2 -> exp = 10
+        // то есть exp = 10^(k-1)
+        countingSortDigit(nums, exp);
+    }
+}
+
+/* Driver Code */
+const nums = [
+    10546151, 35663510, 42865989, 34862445, 81883077, 88906420, 72429244,
+    30524779, 82060337, 63832996,
+];
+radixSort(nums);
+console.log('После поразрядной сортировки nums =', nums);

ru/codes/javascript/chapter_sorting/selection_sort.js

@@ -0,0 +1,27 @@
+/**
+ * File: selection_sort.js
+ * Created Time: 2023-06-04
+ * Author: Justin (xiefahit@gmail.com)
+ */
+
+/* Сортировка выбором */
+function selectionSort(nums) {
+    let n = nums.length;
+    // Внешний цикл: неотсортированный диапазон [i, n-1]
+    for (let i = 0; i < n - 1; i++) {
+        // Внутренний цикл: найти минимальный элемент в неотсортированном диапазоне
+        let k = i;
+        for (let j = i + 1; j < n; j++) {
+            if (nums[j] < nums[k]) {
+                k = j; // Записать индекс минимального элемента
+            }
+        }
+        // Поменять этот минимальный элемент местами с первым элементом неотсортированного диапазона
+        [nums[i], nums[k]] = [nums[k], nums[i]];
+    }
+}
+
+/* Driver Code */
+const nums = [4, 1, 3, 1, 5, 2];
+selectionSort(nums);
+console.log('После сортировки выбором nums =', nums);

ru/codes/javascript/chapter_stack_and_queue/array_deque.js

@@ -0,0 +1,156 @@
+/**
+ * File: array_deque.js
+ * Created Time: 2023-02-28
+ * Author: Zhuo Qinyue (1403450829@qq.com)
+ */
+
+/* Двусторонняя очередь на основе кольцевого массива */
+class ArrayDeque {
+    #nums; // Массив для хранения элементов двусторонней очереди
+    #front; // Указатель head, указывающий на первый элемент очереди
+    #queSize; // Длина двусторонней очереди
+
+    /* Конструктор */
+    constructor(capacity) {
+        this.#nums = new Array(capacity);
+        this.#front = 0;
+        this.#queSize = 0;
+    }
+
+    /* Получить вместимость двусторонней очереди */
+    capacity() {
+        return this.#nums.length;
+    }
+
+    /* Получение длины двусторонней очереди */
+    size() {
+        return this.#queSize;
+    }
+
+    /* Проверка, пуста ли двусторонняя очередь */
+    isEmpty() {
+        return this.#queSize === 0;
+    }
+
+    /* Вычислить индекс в кольцевом массиве */
+    index(i) {
+        // С помощью операции взятия по модулю соединить начало и конец массива
+        // Когда i выходит за конец массива, он возвращается в начало
+        // Когда i выходит за начало массива, он возвращается в конец
+        return (i + this.capacity()) % this.capacity();
+    }
+
+    /* Добавление в голову очереди */
+    pushFirst(num) {
+        if (this.#queSize === this.capacity()) {
+            console.log('Двусторонняя очередь заполнена');
+            return;
+        }
+        // Указатель головы сдвигается на одну позицию влево
+        // С помощью операции взятия по модулю front после выхода за начало массива возвращается в хвост
+        this.#front = this.index(this.#front - 1);
+        // Добавить num в голову очереди
+        this.#nums[this.#front] = num;
+        this.#queSize++;
+    }
+
+    /* Добавление в хвост очереди */
+    pushLast(num) {
+        if (this.#queSize === this.capacity()) {
+            console.log('Двусторонняя очередь заполнена');
+            return;
+        }
+        // Вычислить указатель хвоста, указывающий на индекс хвоста + 1
+        const rear = this.index(this.#front + this.#queSize);
+        // Добавить num в хвост очереди
+        this.#nums[rear] = num;
+        this.#queSize++;
+    }
+
+    /* Извлечение из головы очереди */
+    popFirst() {
+        const num = this.peekFirst();
+        // Указатель головы сдвигается на одну позицию назад
+        this.#front = this.index(this.#front + 1);
+        this.#queSize--;
+        return num;
+    }
+
+    /* Извлечение из хвоста очереди */
+    popLast() {
+        const num = this.peekLast();
+        this.#queSize--;
+        return num;
+    }
+
+    /* Доступ к элементу в начале очереди */
+    peekFirst() {
+        if (this.isEmpty()) throw new Error('The Deque Is Empty.');
+        return this.#nums[this.#front];
+    }
+
+    /* Доступ к элементу в конце очереди */
+    peekLast() {
+        if (this.isEmpty()) throw new Error('The Deque Is Empty.');
+        // Вычислить индекс хвостового элемента
+        const last = this.index(this.#front + this.#queSize - 1);
+        return this.#nums[last];
+    }
+
+    /* Вернуть массив для вывода */
+    toArray() {
+        // Преобразовывать только элементы списка в пределах фактической длины
+        const res = [];
+        for (let i = 0, j = this.#front; i < this.#queSize; i++, j++) {
+            res[i] = this.#nums[this.index(j)];
+        }
+        return res;
+    }
+}
+
+/* Driver Code */
+/* Инициализация двусторонней очереди */
+const capacity = 5;
+const deque = new ArrayDeque(capacity);
+deque.pushLast(3);
+deque.pushLast(2);
+deque.pushLast(5);
+console.log('Двусторонняя очередь deque = [' + deque.toArray() + ']');
+
+/* Доступ к элементу */
+const peekFirst = deque.peekFirst();
+console.log('Первый элемент peekFirst = ' + peekFirst);
+const peekLast = deque.peekLast();
+console.log('Последний элемент peekLast = ' + peekLast);
+
+/* Добавление элемента в очередь */
+deque.pushLast(4);
+console.log('После добавления элемента 4 в хвост deque = [' + deque.toArray() + ']');
+deque.pushFirst(1);
+console.log('После добавления элемента 1 в голову deque = [' + deque.toArray() + ']');
+
+/* Извлечение элемента из очереди */
+const popLast = deque.popLast();
+console.log(
+    'Извлеченный из хвоста элемент = ' +
+        popLast +
+        ', deque после извлечения из хвоста = [' +
+        deque.toArray() +
+        ']'
+);
+const popFirst = deque.popFirst();
+console.log(
+    'Извлеченный из головы элемент = ' +
+        popFirst +
+        ', deque после извлечения из головы = [' +
+        deque.toArray() +
+        ']'
+);
+
+/* Получение длины двусторонней очереди */
+const size = deque.size();
+console.log('Длина двусторонней очереди size = ' + size);
+
+/* Проверка, пуста ли двусторонняя очередь */
+const isEmpty = deque.isEmpty();
+console.log('Пуста ли двусторонняя очередь = ' + isEmpty);

ru/codes/javascript/chapter_stack_and_queue/array_queue.js

@@ -0,0 +1,106 @@
+/**
+ * File: array_queue.js
+ * Created Time: 2022-12-13
+ * Author: S-N-O-R-L-A-X (snorlax.xu@outlook.com)
+ */
+
+/* Очередь на основе кольцевого массива */
+class ArrayQueue {
+    #nums; // Массив для хранения элементов очереди
+    #front = 0; // Указатель head, указывающий на первый элемент очереди
+    #queSize = 0; // Длина очереди
+
+    constructor(capacity) {
+        this.#nums = new Array(capacity);
+    }
+
+    /* Получить вместимость очереди */
+    get capacity() {
+        return this.#nums.length;
+    }
+
+    /* Получение длины очереди */
+    get size() {
+        return this.#queSize;
+    }
+
+    /* Проверка, пуста ли очередь */
+    isEmpty() {
+        return this.#queSize === 0;
+    }
+
+    /* Поместить в очередь */
+    push(num) {
+        if (this.size === this.capacity) {
+            console.log('Очередь заполнена');
+            return;
+        }
+        // Вычислить указатель хвоста, указывающий на индекс хвоста + 1
+        // С помощью операции взятия по модулю вернуть rear к началу после выхода за конец массива
+        const rear = (this.#front + this.size) % this.capacity;
+        // Добавить num в хвост очереди
+        this.#nums[rear] = num;
+        this.#queSize++;
+    }
+
+    /* Извлечь из очереди */
+    pop() {
+        const num = this.peek();
+        // Указатель head сдвигается на одну позицию назад; если он выходит за конец, то возвращается в начало массива
+        this.#front = (this.#front + 1) % this.capacity;
+        this.#queSize--;
+        return num;
+    }
+
+    /* Доступ к элементу в начале очереди */
+    peek() {
+        if (this.isEmpty()) throw new Error('очередь пуста');
+        return this.#nums[this.#front];
+    }
+
+    /* Вернуть Array */
+    toArray() {
+        // Преобразовывать только элементы списка в пределах фактической длины
+        const arr = new Array(this.size);
+        for (let i = 0, j = this.#front; i < this.size; i++, j++) {
+            arr[i] = this.#nums[j % this.capacity];
+        }
+        return arr;
+    }
+}
+
+/* Driver Code */
+/* Инициализация очереди */
+const capacity = 10;
+const queue = new ArrayQueue(capacity);
+
+/* Добавление элемента в очередь */
+queue.push(1);
+queue.push(3);
+queue.push(2);
+queue.push(5);
+queue.push(4);
+console.log('Очередь queue =', queue.toArray());
+
+/* Доступ к элементу в начале очереди */
+const peek = queue.peek();
+console.log('Первый элемент peek = ' + peek);
+
+/* Извлечение элемента из очереди */
+const pop = queue.pop();
+console.log('Извлеченный элемент pop = ' + pop + ', queue после извлечения =', queue.toArray());
+
+/* Получение длины очереди */
+const size = queue.size;
+console.log('Длина очереди size = ' + size);
+
+/* Проверка, пуста ли очередь */
+const isEmpty = queue.isEmpty();
+console.log('Пуста ли очередь = ' + isEmpty);
+
+/* Проверка кольцевого массива */
+for (let i = 0; i < 10; i++) {
+    queue.push(i);
+    queue.pop();
+    console.log('После ' + i + '-го раунда операций enqueue и dequeue queue =', queue.toArray());
+}

ru/codes/javascript/chapter_stack_and_queue/array_stack.js

@@ -0,0 +1,75 @@
+/**
+ * File: array_stack.js
+ * Created Time: 2022-12-09
+ * Author: S-N-O-R-L-A-X (snorlax.xu@outlook.com)
+ */
+
+/* Стек на основе массива */
+class ArrayStack {
+    #stack;
+    constructor() {
+        this.#stack = [];
+    }
+
+    /* Получение длины стека */
+    get size() {
+        return this.#stack.length;
+    }
+
+    /* Проверка, пуст ли стек */
+    isEmpty() {
+        return this.#stack.length === 0;
+    }
+
+    /* Поместить в стек */
+    push(num) {
+        this.#stack.push(num);
+    }
+
+    /* Извлечь из стека */
+    pop() {
+        if (this.isEmpty()) throw new Error('стек пуст');
+        return this.#stack.pop();
+    }
+
+    /* Доступ к верхнему элементу стека */
+    top() {
+        if (this.isEmpty()) throw new Error('стек пуст');
+        return this.#stack[this.#stack.length - 1];
+    }
+
+    /* Вернуть Array */
+    toArray() {
+        return this.#stack;
+    }
+}
+
+/* Driver Code */
+/* Инициализация стека */
+const stack = new ArrayStack();
+
+/* Помещение элемента в стек */
+stack.push(1);
+stack.push(3);
+stack.push(2);
+stack.push(5);
+stack.push(4);
+console.log('Стек stack = ');
+console.log(stack.toArray());
+
+/* Доступ к верхнему элементу стека */
+const top = stack.top();
+console.log('Верхний элемент top = ' + top);
+
+/* Извлечение элемента из стека */
+const pop = stack.pop();
+console.log('Извлеченный элемент pop = ' + pop + ', stack после извлечения = ');
+console.log(stack.toArray());
+
+/* Получение длины стека */
+const size = stack.size;
+console.log('Длина стека size = ' + size);
+
+/* Проверка на пустоту */
+const isEmpty = stack.isEmpty();
+console.log('Пуст ли стек = ' + isEmpty);

ru/codes/javascript/chapter_stack_and_queue/deque.js

@@ -0,0 +1,44 @@
+/**
+ * File: deque.js
+ * Created Time: 2023-01-17
+ * Author: Zhuo Qinyue (1403450829@qq.com)
+ */
+
+/* Driver Code */
+/* Инициализация двусторонней очереди */
+// В JavaScript нет встроенной двусторонней очереди, поэтому Array можно использовать как двустороннюю очередь
+const deque = [];
+
+/* Добавление элемента в очередь */
+deque.push(2);
+deque.push(5);
+deque.push(4);
+// Обратите внимание: поскольку используется массив, временная сложность метода unshift() равна O(n)
+deque.unshift(3);
+deque.unshift(1);
+console.log('Двусторонняя очередь deque = ', deque);
+
+/* Доступ к элементу */
+const peekFirst = deque[0];
+console.log('Первый элемент peekFirst = ' + peekFirst);
+const peekLast = deque[deque.length - 1];
+console.log('Последний элемент peekLast = ' + peekLast);
+
+/* Извлечение элемента из очереди */
+// Обратите внимание: поскольку используется массив, временная сложность метода shift() равна O(n)
+const popFront = deque.shift();
+console.log(
+    'Извлеченный из головы элемент popFront = ' + popFront + ', deque после извлечения из головы = ' + deque
+);
+const popBack = deque.pop();
+console.log(
+    'Извлеченный из хвоста элемент popBack = ' + popBack + ', deque после извлечения из хвоста = ' + deque
+);
+
+/* Получение длины двусторонней очереди */
+const size = deque.length;
+console.log('Длина двусторонней очереди size = ' + size);
+
+/* Проверка, пуста ли двусторонняя очередь */
+const isEmpty = size === 0;
+console.log('Пуста ли двусторонняя очередь = ' + isEmpty);

ru/codes/javascript/chapter_stack_and_queue/linkedlist_deque.js

@@ -0,0 +1,167 @@
+/**
+ * File: linkedlist_deque.js
+ * Created Time: 2023-02-04
+ * Author: Zhuo Qinyue (1403450829@qq.com)
+ */
+
+/* Узел двусвязного списка */
+class ListNode {
+    prev; // Ссылка на узел-предшественник (указатель)
+    next; // Ссылка на узел-преемник (указатель)
+    val; // Значение узла
+
+    constructor(val) {
+        this.val = val;
+        this.next = null;
+        this.prev = null;
+    }
+}
+
+/* Двусторонняя очередь на основе двусвязного списка */
+class LinkedListDeque {
+    #front; // Головной узел front
+    #rear; // Хвостовой узел rear
+    #queSize; // Длина двусторонней очереди
+
+    constructor() {
+        this.#front = null;
+        this.#rear = null;
+        this.#queSize = 0;
+    }
+
+    /* Операция добавления в хвост очереди */
+    pushLast(val) {
+        const node = new ListNode(val);
+        // Если связный список пуст, сделать так, чтобы и front, и rear указывали на node
+        if (this.#queSize === 0) {
+            this.#front = node;
+            this.#rear = node;
+        } else {
+            // Добавить node в хвост списка
+            this.#rear.next = node;
+            node.prev = this.#rear;
+            this.#rear = node; // Обновить хвостовой узел
+        }
+        this.#queSize++;
+    }
+
+    /* Операция добавления в голову очереди */
+    pushFirst(val) {
+        const node = new ListNode(val);
+        // Если связный список пуст, сделать так, чтобы и front, и rear указывали на node
+        if (this.#queSize === 0) {
+            this.#front = node;
+            this.#rear = node;
+        } else {
+            // Добавить node в голову списка
+            this.#front.prev = node;
+            node.next = this.#front;
+            this.#front = node; // Обновить головной узел
+        }
+        this.#queSize++;
+    }
+
+    /* Операция извлечения из хвоста очереди */
+    popLast() {
+        if (this.#queSize === 0) {
+            return null;
+        }
+        const value = this.#rear.val; // Сохранить значение хвостового узла
+        // Удалить хвостовой узел
+        let temp = this.#rear.prev;
+        if (temp !== null) {
+            temp.next = null;
+            this.#rear.prev = null;
+        }
+        this.#rear = temp; // Обновить хвостовой узел
+        this.#queSize--;
+        return value;
+    }
+
+    /* Операция извлечения из головы очереди */
+    popFirst() {
+        if (this.#queSize === 0) {
+            return null;
+        }
+        const value = this.#front.val; // Сохранить значение хвостового узла
+        // Удалить головной узел
+        let temp = this.#front.next;
+        if (temp !== null) {
+            temp.prev = null;
+            this.#front.next = null;
+        }
+        this.#front = temp; // Обновить головной узел
+        this.#queSize--;
+        return value;
+    }
+
+    /* Доступ к элементу в конце очереди */
+    peekLast() {
+        return this.#queSize === 0 ? null : this.#rear.val;
+    }
+
+    /* Доступ к элементу в начале очереди */
+    peekFirst() {
+        return this.#queSize === 0 ? null : this.#front.val;
+    }
+
+    /* Получение длины двусторонней очереди */
+    size() {
+        return this.#queSize;
+    }
+
+    /* Проверка, пуста ли двусторонняя очередь */
+    isEmpty() {
+        return this.#queSize === 0;
+    }
+
+    /* Вывести двустороннюю очередь */
+    print() {
+        const arr = [];
+        let temp = this.#front;
+        while (temp !== null) {
+            arr.push(temp.val);
+            temp = temp.next;
+        }
+        console.log('[' + arr.join(', ') + ']');
+    }
+}
+
+/* Driver Code */
+/* Инициализация двусторонней очереди */
+const linkedListDeque = new LinkedListDeque();
+linkedListDeque.pushLast(3);
+linkedListDeque.pushLast(2);
+linkedListDeque.pushLast(5);
+console.log('Двусторонняя очередь linkedListDeque = ');
+linkedListDeque.print();
+
+/* Доступ к элементу */
+const peekFirst = linkedListDeque.peekFirst();
+console.log('Первый элемент peekFirst = ' + peekFirst);
+const peekLast = linkedListDeque.peekLast();
+console.log('Последний элемент peekLast = ' + peekLast);
+
+/* Добавление элемента в очередь */
+linkedListDeque.pushLast(4);
+console.log('После добавления элемента 4 в хвост linkedListDeque = ');
+linkedListDeque.print();
+linkedListDeque.pushFirst(1);
+console.log('После добавления элемента 1 в голову linkedListDeque = ');
+linkedListDeque.print();
+
+/* Извлечение элемента из очереди */
+const popLast = linkedListDeque.popLast();
+console.log('Извлеченный из хвоста элемент = ' + popLast + ', linkedListDeque после извлечения из хвоста = ');
+linkedListDeque.print();
+const popFirst = linkedListDeque.popFirst();
+console.log('Извлеченный из головы элемент = ' + popFirst + ', linkedListDeque после извлечения из головы = ');
+linkedListDeque.print();
+
+/* Получение длины двусторонней очереди */
+const size = linkedListDeque.size();
+console.log('Длина двусторонней очереди size = ' + size);
+
+/* Проверка, пуста ли двусторонняя очередь */
+const isEmpty = linkedListDeque.isEmpty();
+console.log('Пуста ли двусторонняя очередь = ' + isEmpty);

ru/codes/javascript/chapter_stack_and_queue/linkedlist_queue.js

@@ -0,0 +1,99 @@
+/**
+ * File: linkedlist_queue.js
+ * Created Time: 2022-12-20
+ * Author: S-N-O-R-L-A-X (snorlax.xu@outlook.com)
+ */
+
+const { ListNode } = require('../modules/ListNode');
+
+/* Очередь на основе связного списка */
+class LinkedListQueue {
+    #front; // Головной узел #front
+    #rear; // Хвостовой узел #rear
+    #queSize = 0;
+
+    constructor() {
+        this.#front = null;
+        this.#rear = null;
+    }
+
+    /* Получение длины очереди */
+    get size() {
+        return this.#queSize;
+    }
+
+    /* Проверка, пуста ли очередь */
+    isEmpty() {
+        return this.size === 0;
+    }
+
+    /* Поместить в очередь */
+    push(num) {
+        // Добавить num после хвостового узла
+        const node = new ListNode(num);
+        // Если очередь пуста, сделать так, чтобы и head, и tail указывали на этот узел
+        if (!this.#front) {
+            this.#front = node;
+            this.#rear = node;
+            // Если очередь не пуста, добавить этот узел после хвостового узла
+        } else {
+            this.#rear.next = node;
+            this.#rear = node;
+        }
+        this.#queSize++;
+    }
+
+    /* Извлечь из очереди */
+    pop() {
+        const num = this.peek();
+        // Удалить головной узел
+        this.#front = this.#front.next;
+        this.#queSize--;
+        return num;
+    }
+
+    /* Доступ к элементу в начале очереди */
+    peek() {
+        if (this.size === 0) throw new Error('очередь пуста');
+        return this.#front.val;
+    }
+
+    /* Преобразовать связный список в Array и вернуть */
+    toArray() {
+        let node = this.#front;
+        const res = new Array(this.size);
+        for (let i = 0; i < res.length; i++) {
+            res[i] = node.val;
+            node = node.next;
+        }
+        return res;
+    }
+}
+
+/* Driver Code */
+/* Инициализация очереди */
+const queue = new LinkedListQueue();
+
+/* Добавление элемента в очередь */
+queue.push(1);
+queue.push(3);
+queue.push(2);
+queue.push(5);
+queue.push(4);
+console.log('Очередь queue = ' + queue.toArray());
+
+/* Доступ к элементу в начале очереди */
+const peek = queue.peek();
+console.log('Первый элемент peek = ' + peek);
+
+/* Извлечение элемента из очереди */
+const pop = queue.pop();
+console.log('Извлеченный элемент pop = ' + pop + ', queue после извлечения = ' + queue.toArray());
+
+/* Получение длины очереди */
+const size = queue.size;
+console.log('Длина очереди size = ' + size);
+
+/* Проверка, пуста ли очередь */
+const isEmpty = queue.isEmpty();
+console.log('Пуста ли очередь = ' + isEmpty);

ru/codes/javascript/chapter_stack_and_queue/linkedlist_stack.js

@@ -0,0 +1,88 @@
+/**
+ * File: linkedlist_stack.js
+ * Created Time: 2022-12-22
+ * Author: S-N-O-R-L-A-X (snorlax.xu@outlook.com)
+ */
+
+const { ListNode } = require('../modules/ListNode');
+
+/* Стек на основе связного списка */
+class LinkedListStack {
+    #stackPeek; // Использовать головной узел как вершину стека
+    #stkSize = 0; // Длина стека
+
+    constructor() {
+        this.#stackPeek = null;
+    }
+
+    /* Получение длины стека */
+    get size() {
+        return this.#stkSize;
+    }
+
+    /* Проверка, пуст ли стек */
+    isEmpty() {
+        return this.size === 0;
+    }
+
+    /* Поместить в стек */
+    push(num) {
+        const node = new ListNode(num);
+        node.next = this.#stackPeek;
+        this.#stackPeek = node;
+        this.#stkSize++;
+    }
+
+    /* Извлечь из стека */
+    pop() {
+        const num = this.peek();
+        this.#stackPeek = this.#stackPeek.next;
+        this.#stkSize--;
+        return num;
+    }
+
+    /* Доступ к верхнему элементу стека */
+    peek() {
+        if (!this.#stackPeek) throw new Error('стек пуст');
+        return this.#stackPeek.val;
+    }
+
+    /* Преобразовать связный список в Array и вернуть */
+    toArray() {
+        let node = this.#stackPeek;
+        const res = new Array(this.size);
+        for (let i = res.length - 1; i >= 0; i--) {
+            res[i] = node.val;
+            node = node.next;
+        }
+        return res;
+    }
+}
+
+/* Driver Code */
+/* Инициализация стека */
+const stack = new LinkedListStack();
+
+/* Помещение элемента в стек */
+stack.push(1);
+stack.push(3);
+stack.push(2);
+stack.push(5);
+stack.push(4);
+console.log('Стек stack = ' + stack.toArray());
+
+/* Доступ к верхнему элементу стека */
+const peek = stack.peek();
+console.log('Верхний элемент peek = ' + peek);
+
+/* Извлечение элемента из стека */
+const pop = stack.pop();
+console.log('Извлеченный элемент pop = ' + pop + ', stack после извлечения = ' + stack.toArray());
+
+/* Получение длины стека */
+const size = stack.size;
+console.log('Длина стека size = ' + size);
+
+/* Проверка на пустоту */
+const isEmpty = stack.isEmpty();
+console.log('Пуст ли стек = ' + isEmpty);

ru/codes/javascript/chapter_stack_and_queue/queue.js

@@ -0,0 +1,35 @@
+/**
+ * File: queue.js
+ * Created Time: 2022-12-05
+ * Author: S-N-O-R-L-A-X (snorlax.xu@outlook.com)
+ */
+
+/* Driver Code */
+/* Инициализация очереди */
+// В JavaScript нет встроенной очереди, поэтому Array можно использовать как очередь
+const queue = [];
+
+/* Добавление элемента в очередь */
+queue.push(1);
+queue.push(3);
+queue.push(2);
+queue.push(5);
+queue.push(4);
+console.log('Очередь queue =', queue);
+
+/* Доступ к элементу в начале очереди */
+const peek = queue[0];
+console.log('Первый элемент peek =', peek);
+
+/* Извлечение элемента из очереди */
+// В основе лежит массив, поэтому временная сложность метода shift() равна O(n)
+const pop = queue.shift();
+console.log('Извлеченный элемент pop =', pop, ', queue после извлечения = ', queue);
+
+/* Получение длины очереди */
+const size = queue.length;
+console.log('Длина очереди size =', size);
+
+/* Проверка, пуста ли очередь */
+const isEmpty = queue.length === 0;
+console.log('Пуста ли очередь = ', isEmpty);

ru/codes/javascript/chapter_stack_and_queue/stack.js

@@ -0,0 +1,35 @@
+/**
+ * File: stack.js
+ * Created Time: 2022-12-04
+ * Author: S-N-O-R-L-A-X (snorlax.xu@outlook.com)
+ */
+
+/* Driver Code */
+/* Инициализация стека */
+// В JavaScript нет встроенного класса стека, поэтому Array можно использовать как стек
+const stack = [];
+
+/* Помещение элемента в стек */
+stack.push(1);
+stack.push(3);
+stack.push(2);
+stack.push(5);
+stack.push(4);
+console.log('Стек stack =', stack);
+
+/* Доступ к верхнему элементу стека */
+const peek = stack[stack.length - 1];
+console.log('Верхний элемент peek =', peek);
+
+/* Извлечение элемента из стека */
+const pop = stack.pop();
+console.log('Извлеченный элемент pop =', pop);
+console.log('stack после извлечения =', stack);
+
+/* Получение длины стека */
+const size = stack.length;
+console.log('Длина стека size =', size);
+
+/* Проверка на пустоту */
+const isEmpty = stack.length === 0;
+console.log('Пуст ли стек =', isEmpty);

ru/codes/javascript/chapter_tree/array_binary_tree.js

@@ -0,0 +1,147 @@
+/**
+ * File: array_binary_tree.js
+ * Created Time: 2023-08-06
+ * Author: yuan0221 (yl1452491917@gmail.com)
+ */
+
+const { arrToTree } = require('../modules/TreeNode');
+const { printTree } = require('../modules/PrintUtil');
+
+/* Класс двоичного дерева в массивном представлении */
+class ArrayBinaryTree {
+    #tree;
+
+    /* Конструктор */
+    constructor(arr) {
+        this.#tree = arr;
+    }
+
+    /* Вместимость списка */
+    size() {
+        return this.#tree.length;
+    }
+
+    /* Получить значение узла с индексом i */
+    val(i) {
+        // Если индекс выходит за границы, вернуть null, обозначающий пустую позицию
+        if (i < 0 || i >= this.size()) return null;
+        return this.#tree[i];
+    }
+
+    /* Получить индекс левого дочернего узла узла с индексом i */
+    left(i) {
+        return 2 * i + 1;
+    }
+
+    /* Получить индекс правого дочернего узла узла с индексом i */
+    right(i) {
+        return 2 * i + 2;
+    }
+
+    /* Получить индекс родительского узла узла с индексом i */
+    parent(i) {
+        return Math.floor((i - 1) / 2); // Округление вниз при делении
+    }
+
+    /* Обход в ширину */
+    levelOrder() {
+        let res = [];
+        // Непосредственно обходить массив
+        for (let i = 0; i < this.size(); i++) {
+            if (this.val(i) !== null) res.push(this.val(i));
+        }
+        return res;
+    }
+
+    /* Обход в глубину */
+    #dfs(i, order, res) {
+        // Если это пустая позиция, вернуть
+        if (this.val(i) === null) return;
+        // Предварительный обход
+        if (order === 'pre') res.push(this.val(i));
+        this.#dfs(this.left(i), order, res);
+        // Симметричный обход
+        if (order === 'in') res.push(this.val(i));
+        this.#dfs(this.right(i), order, res);
+        // Обратный обход
+        if (order === 'post') res.push(this.val(i));
+    }
+
+    /* Предварительный обход */
+    preOrder() {
+        const res = [];
+        this.#dfs(0, 'pre', res);
+        return res;
+    }
+
+    /* Симметричный обход */
+    inOrder() {
+        const res = [];
+        this.#dfs(0, 'in', res);
+        return res;
+    }
+
+    /* Обратный обход */
+    postOrder() {
+        const res = [];
+        this.#dfs(0, 'post', res);
+        return res;
+    }
+}
+
+/* Driver Code */
+// Инициализировать двоичное дерево
+// Здесь используется функция, напрямую строящая двоичное дерево из массива
+const arr = Array.of(
+    1,
+    2,
+    3,
+    4,
+    null,
+    6,
+    7,
+    8,
+    9,
+    null,
+    null,
+    12,
+    null,
+    null,
+    15
+);
+
+const root = arrToTree(arr);
+console.log('\nИнициализация двоичного дерева\n');
+console.log('Массивное представление двоичного дерева:');
+console.log(arr);
+console.log('Связное представление двоичного дерева:');
+printTree(root);
+
+// Класс двоичного дерева в массивном представлении
+const abt = new ArrayBinaryTree(arr);
+
+// Доступ к узлу
+const i = 1;
+const l = abt.left(i);
+const r = abt.right(i);
+const p = abt.parent(i);
+console.log('\nТекущий узел: индекс = ' + i + ', значение = ' + abt.val(i));
+console.log(
+    'Индекс левого дочернего узла = ' + l + ', значение = ' + (l === null ? 'null' : abt.val(l))
+);
+console.log(
+    'Индекс правого дочернего узла = ' + r + ', значение = ' + (r === null ? 'null' : abt.val(r))
+);
+console.log(
+    'Индекс родительского узла = ' + p + ', значение = ' + (p === null ? 'null' : abt.val(p))
+);
+
+// Обходить дерево
+let res = abt.levelOrder();
+console.log('\nОбход в ширину: ' + res);
+res = abt.preOrder();
+console.log('Предварительный обход: ' + res);
+res = abt.inOrder();
+console.log('Симметричный обход: ' + res);
+res = abt.postOrder();
+console.log('Обратный обход: ' + res);

ru/codes/javascript/chapter_tree/avl_tree.js

@@ -0,0 +1,208 @@
+/**
+ * File: avl_tree.js
+ * Created Time: 2023-02-05
+ * Author: what-is-me (whatisme@outlook.jp)
+ */
+
+const { TreeNode } = require('../modules/TreeNode');
+const { printTree } = require('../modules/PrintUtil');
+
+/* AVL-дерево */
+class AVLTree {
+    /* Конструктор */
+    constructor() {
+        this.root = null; // Корневой узел
+    }
+
+    /* Получить высоту узла */
+    height(node) {
+        // Высота пустого узла равна -1, высота листового узла равна 0
+        return node === null ? -1 : node.height;
+    }
+
+    /* Обновить высоту узла */
+    #updateHeight(node) {
+        // Высота узла равна высоте более высокого поддерева + 1
+        node.height =
+            Math.max(this.height(node.left), this.height(node.right)) + 1;
+    }
+
+    /* Получить коэффициент баланса */
+    balanceFactor(node) {
+        // Коэффициент баланса пустого узла равен 0
+        if (node === null) return 0;
+        // Коэффициент баланса узла = высота левого поддерева - высота правого поддерева
+        return this.height(node.left) - this.height(node.right);
+    }
+
+    /* Операция правого вращения */
+    #rightRotate(node) {
+        const child = node.left;
+        const grandChild = child.right;
+        // Выполнить правое вращение узла node вокруг child
+        child.right = node;
+        node.left = grandChild;
+        // Обновить высоту узла
+        this.#updateHeight(node);
+        this.#updateHeight(child);
+        // Вернуть корневой узел поддерева после вращения
+        return child;
+    }
+
+    /* Операция левого вращения */
+    #leftRotate(node) {
+        const child = node.right;
+        const grandChild = child.left;
+        // Выполнить левое вращение узла node вокруг child
+        child.left = node;
+        node.right = grandChild;
+        // Обновить высоту узла
+        this.#updateHeight(node);
+        this.#updateHeight(child);
+        // Вернуть корневой узел поддерева после вращения
+        return child;
+    }
+
+    /* Выполнить вращение, чтобы снова сбалансировать поддерево */
+    #rotate(node) {
+        // Получить коэффициент баланса узла node
+        const balanceFactor = this.balanceFactor(node);
+        // Левосторонне перекошенное дерево
+        if (balanceFactor > 1) {
+            if (this.balanceFactor(node.left) >= 0) {
+                // Правое вращение
+                return this.#rightRotate(node);
+            } else {
+                // Сначала левое вращение, затем правое
+                node.left = this.#leftRotate(node.left);
+                return this.#rightRotate(node);
+            }
+        }
+        // Правосторонне перекошенное дерево
+        if (balanceFactor < -1) {
+            if (this.balanceFactor(node.right) <= 0) {
+                // Левое вращение
+                return this.#leftRotate(node);
+            } else {
+                // Сначала правое вращение, затем левое
+                node.right = this.#rightRotate(node.right);
+                return this.#leftRotate(node);
+            }
+        }
+        // Дерево сбалансировано, вращение не требуется, вернуть сразу
+        return node;
+    }
+
+    /* Вставка узла */
+    insert(val) {
+        this.root = this.#insertHelper(this.root, val);
+    }
+
+    /* Рекурсивная вставка узла (вспомогательный метод) */
+    #insertHelper(node, val) {
+        if (node === null) return new TreeNode(val);
+        /* 1. Найти позицию вставки и вставить узел */
+        if (val < node.val) node.left = this.#insertHelper(node.left, val);
+        else if (val > node.val)
+            node.right = this.#insertHelper(node.right, val);
+        else return node; // Повторяющийся узел не вставлять, сразу вернуть
+        this.#updateHeight(node); // Обновить высоту узла
+        /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */
+        node = this.#rotate(node);
+        // Вернуть корневой узел поддерева
+        return node;
+    }
+
+    /* Удаление узла */
+    remove(val) {
+        this.root = this.#removeHelper(this.root, val);
+    }
+
+    /* Рекурсивное удаление узла (вспомогательный метод) */
+    #removeHelper(node, val) {
+        if (node === null) return null;
+        /* 1. Найти узел и удалить его */
+        if (val < node.val) node.left = this.#removeHelper(node.left, val);
+        else if (val > node.val)
+            node.right = this.#removeHelper(node.right, val);
+        else {
+            if (node.left === null || node.right === null) {
+                const child = node.left !== null ? node.left : node.right;
+                // Число дочерних узлов = 0, удалить node и сразу вернуть
+                if (child === null) return null;
+                // Число дочерних узлов = 1, удалить node напрямую
+                else node = child;
+            } else {
+                // Число дочерних узлов = 2, удалить следующий по симметричному обходу узел и заменить им текущий узел
+                let temp = node.right;
+                while (temp.left !== null) {
+                    temp = temp.left;
+                }
+                node.right = this.#removeHelper(node.right, temp.val);
+                node.val = temp.val;
+            }
+        }
+        this.#updateHeight(node); // Обновить высоту узла
+        /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */
+        node = this.#rotate(node);
+        // Вернуть корневой узел поддерева
+        return node;
+    }
+
+    /* Поиск узла */
+    search(val) {
+        let cur = this.root;
+        // Искать в цикле и выйти после прохода за листовой узел
+        while (cur !== null) {
+            // Целевой узел находится в правом поддереве cur
+            if (cur.val < val) cur = cur.right;
+            // Целевой узел находится в левом поддереве cur
+            else if (cur.val > val) cur = cur.left;
+            // Найти целевой узел и выйти из цикла
+            else break;
+        }
+        // Вернуть целевой узел
+        return cur;
+    }
+}
+
+function testInsert(tree, val) {
+    tree.insert(val);
+    console.log('\nПосле вставки узла ' + val + ' AVL-дерево имеет вид');
+    printTree(tree.root);
+}
+
+function testRemove(tree, val) {
+    tree.remove(val);
+    console.log('\nПосле удаления узла ' + val + ' AVL-дерево имеет вид');
+    printTree(tree.root);
+}
+
+/* Driver Code */
+/* Инициализация пустого AVL-дерева */
+const avlTree = new AVLTree();
+/* Вставка узла */
+// Обратите внимание, как AVL-дерево сохраняет баланс после вставки узла
+testInsert(avlTree, 1);
+testInsert(avlTree, 2);
+testInsert(avlTree, 3);
+testInsert(avlTree, 4);
+testInsert(avlTree, 5);
+testInsert(avlTree, 8);
+testInsert(avlTree, 7);
+testInsert(avlTree, 9);
+testInsert(avlTree, 10);
+testInsert(avlTree, 6);
+
+/* Вставка повторяющегося узла */
+testInsert(avlTree, 7);
+
+/* Удаление узла */
+// Обратите внимание, как AVL-дерево сохраняет баланс после удаления узла
+testRemove(avlTree, 8); // Удаление узла степени 0
+testRemove(avlTree, 5); // Удаление узла степени 1
+testRemove(avlTree, 4); // Удаление узла степени 2
+
+/* Поиск узла */
+const node = avlTree.search(7);
+console.log('\nНайденный объект узла =', node, ', значение узла = ' + node.val);

ru/codes/javascript/chapter_tree/binary_search_tree.js

@@ -0,0 +1,139 @@
+/**
+ * File: binary_search_tree.js
+ * Created Time: 2022-12-04
+ * Author: IsChristina (christinaxia77@foxmail.com)
+ */
+
+const { TreeNode } = require('../modules/TreeNode');
+const { printTree } = require('../modules/PrintUtil');
+
+/* Двоичное дерево поиска */
+class BinarySearchTree {
+    /* Конструктор */
+    constructor() {
+        // Инициализировать пустое дерево
+        this.root = null;
+    }
+
+    /* Получить корневой узел двоичного дерева */
+    getRoot() {
+        return this.root;
+    }
+
+    /* Поиск узла */
+    search(num) {
+        let cur = this.root;
+        // Искать в цикле и выйти после прохода за листовой узел
+        while (cur !== null) {
+            // Целевой узел находится в правом поддереве cur
+            if (cur.val < num) cur = cur.right;
+            // Целевой узел находится в левом поддереве cur
+            else if (cur.val > num) cur = cur.left;
+            // Найти целевой узел и выйти из цикла
+            else break;
+        }
+        // Вернуть целевой узел
+        return cur;
+    }
+
+    /* Вставка узла */
+    insert(num) {
+        // Если дерево пусто, инициализировать корневой узел
+        if (this.root === null) {
+            this.root = new TreeNode(num);
+            return;
+        }
+        let cur = this.root,
+            pre = null;
+        // Искать в цикле и выйти после прохода за листовой узел
+        while (cur !== null) {
+            // Найти повторяющийся узел и сразу вернуть
+            if (cur.val === num) return;
+            pre = cur;
+            // Позиция вставки находится в правом поддереве cur
+            if (cur.val < num) cur = cur.right;
+            // Позиция вставки находится в левом поддереве cur
+            else cur = cur.left;
+        }
+        // Вставка узла
+        const node = new TreeNode(num);
+        if (pre.val < num) pre.right = node;
+        else pre.left = node;
+    }
+
+    /* Удаление узла */
+    remove(num) {
+        // Если дерево пусто, сразу вернуть
+        if (this.root === null) return;
+        let cur = this.root,
+            pre = null;
+        // Искать в цикле и выйти после прохода за листовой узел
+        while (cur !== null) {
+            // Найти узел для удаления и выйти из цикла
+            if (cur.val === num) break;
+            pre = cur;
+            // Узел для удаления находится в правом поддереве cur
+            if (cur.val < num) cur = cur.right;
+            // Узел для удаления находится в левом поддереве cur
+            else cur = cur.left;
+        }
+        // Если узел для удаления отсутствует, сразу вернуть
+        if (cur === null) return;
+        // Число дочерних узлов = 0 или 1
+        if (cur.left === null || cur.right === null) {
+            // Когда число дочерних узлов = 0 / 1, child = null / этот дочерний узел
+            const child = cur.left !== null ? cur.left : cur.right;
+            // Удалить узел cur
+            if (cur !== this.root) {
+                if (pre.left === cur) pre.left = child;
+                else pre.right = child;
+            } else {
+                // Если удаляемый узел является корнем, заново назначить корневой узел
+                this.root = child;
+            }
+        }
+        // Число дочерних узлов = 2
+        else {
+            // Получить следующий узел после cur в симметричном обходе
+            let tmp = cur.right;
+            while (tmp.left !== null) {
+                tmp = tmp.left;
+            }
+            // Рекурсивно удалить узел tmp
+            this.remove(tmp.val);
+            // Перезаписать cur значением tmp
+            cur.val = tmp.val;
+        }
+    }
+}
+
+/* Driver Code */
+/* Инициализация двоичного дерева поиска */
+const bst = new BinarySearchTree();
+// Обратите внимание: разные порядки вставки порождают разные двоичные деревья; данная последовательность может построить совершенное двоичное дерево
+const nums = [8, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13, 15];
+for (const num of nums) {
+    bst.insert(num);
+}
+console.log('\nИсходное двоичное дерево\n');
+printTree(bst.getRoot());
+
+/* Поиск узла */
+const node = bst.search(7);
+console.log('\nНайденный объект узла = ' + node + ', значение узла = ' + node.val);
+
+/* Вставка узла */
+bst.insert(16);
+console.log('\nПосле вставки узла 16 двоичное дерево имеет вид\n');
+printTree(bst.getRoot());
+
+/* Удаление узла */
+bst.remove(1);
+console.log('\nПосле удаления узла 1 двоичное дерево имеет вид\n');
+printTree(bst.getRoot());
+bst.remove(2);
+console.log('\nПосле удаления узла 2 двоичное дерево имеет вид\n');
+printTree(bst.getRoot());
+bst.remove(4);
+console.log('\nПосле удаления узла 4 двоичное дерево имеет вид\n');
+printTree(bst.getRoot());

ru/codes/javascript/chapter_tree/binary_tree.js

@@ -0,0 +1,35 @@
+/**
+ * File: binary_tree.js
+ * Created Time: 2022-12-04
+ * Author: IsChristina (christinaxia77@foxmail.com)
+ */
+
+const { TreeNode } = require('../modules/TreeNode');
+const { printTree } = require('../modules/PrintUtil');
+
+/* Инициализация двоичного дерева */
+// Инициализация узла
+let n1 = new TreeNode(1),
+    n2 = new TreeNode(2),
+    n3 = new TreeNode(3),
+    n4 = new TreeNode(4),
+    n5 = new TreeNode(5);
+// Построить связи между узлами (указатели)
+n1.left = n2;
+n1.right = n3;
+n2.left = n4;
+n2.right = n5;
+console.log('\nИнициализация двоичного дерева\n');
+printTree(n1);
+
+/* Вставка и удаление узлов */
+const P = new TreeNode(0);
+// Вставить узел P между n1 -> n2
+n1.left = P;
+P.left = n2;
+console.log('\nПосле вставки узла P\n');
+printTree(n1);
+// Удалить узел P
+n1.left = n2;
+console.log('\nПосле удаления узла P\n');
+printTree(n1);

ru/codes/javascript/chapter_tree/binary_tree_bfs.js

@@ -0,0 +1,34 @@
+/**
+ * File: binary_tree_bfs.js
+ * Created Time: 2022-12-04
+ * Author: IsChristina (christinaxia77@foxmail.com)
+ */
+
+const { arrToTree } = require('../modules/TreeNode');
+const { printTree } = require('../modules/PrintUtil');
+
+/* Обход в ширину */
+function levelOrder(root) {
+    // Инициализировать очередь и добавить корневой узел
+    const queue = [root];
+    // Инициализировать список для хранения последовательности обхода
+    const list = [];
+    while (queue.length) {
+        let node = queue.shift(); // Извлечение из очереди
+        list.push(node.val); // Сохранить значение узла
+        if (node.left) queue.push(node.left); // Поместить левый дочерний узел в очередь
+        if (node.right) queue.push(node.right); // Поместить правый дочерний узел в очередь
+    }
+    return list;
+}
+
+/* Driver Code */
+/* Инициализация двоичного дерева */
+// Здесь используется функция, напрямую строящая двоичное дерево из массива
+const root = arrToTree([1, 2, 3, 4, 5, 6, 7]);
+console.log('\nИнициализация двоичного дерева\n');
+printTree(root);
+
+/* Обход в ширину */
+const list = levelOrder(root);
+console.log('\nПоследовательность печати узлов при обходе в ширину = ' + list);

ru/codes/javascript/chapter_tree/binary_tree_dfs.js

@@ -0,0 +1,60 @@
+/**
+ * File: binary_tree_dfs.js
+ * Created Time: 2022-12-04
+ * Author: IsChristina (christinaxia77@foxmail.com)
+ */
+
+const { arrToTree } = require('../modules/TreeNode');
+const { printTree } = require('../modules/PrintUtil');
+
+// Инициализировать список для хранения последовательности обхода
+const list = [];
+
+/* Предварительный обход */
+function preOrder(root) {
+    if (root === null) return;
+    // Порядок обхода: корень -> левое поддерево -> правое поддерево
+    list.push(root.val);
+    preOrder(root.left);
+    preOrder(root.right);
+}
+
+/* Симметричный обход */
+function inOrder(root) {
+    if (root === null) return;
+    // Порядок обхода: левое поддерево -> корень -> правое поддерево
+    inOrder(root.left);
+    list.push(root.val);
+    inOrder(root.right);
+}
+
+/* Обратный обход */
+function postOrder(root) {
+    if (root === null) return;
+    // Порядок обхода: левое поддерево -> правое поддерево -> корень
+    postOrder(root.left);
+    postOrder(root.right);
+    list.push(root.val);
+}
+
+/* Driver Code */
+/* Инициализация двоичного дерева */
+// Здесь используется функция, напрямую строящая двоичное дерево из массива
+const root = arrToTree([1, 2, 3, 4, 5, 6, 7]);
+console.log('\nИнициализация двоичного дерева\n');
+printTree(root);
+
+/* Предварительный обход */
+list.length = 0;
+preOrder(root);
+console.log('\nПоследовательность печати узлов при предварительном обходе = ' + list);
+
+/* Симметричный обход */
+list.length = 0;
+inOrder(root);
+console.log('\nПоследовательность печати узлов при симметричном обходе = ' + list);
+
+/* Обратный обход */
+list.length = 0;
+postOrder(root);
+console.log('\nПоследовательность печати узлов при обратном обходе = ' + list);

ru/codes/javascript/modules/ListNode.js

@@ -0,0 +1,31 @@
+/**
+ * File: ListNode.js
+ * Created Time: 2022-12-12
+ * Author: IsChristina (christinaxia77@foxmail.com)
+ */
+
+/* Узел связного списка */
+class ListNode {
+    val; // Значение узла
+    next; // Ссылка (указатель) на следующий узел
+    constructor(val, next) {
+        this.val = val === undefined ? 0 : val;
+        this.next = next === undefined ? null : next;
+    }
+}
+
+/* Десериализовать список в связный список */
+function arrToLinkedList(arr) {
+    const dum = new ListNode(0);
+    let head = dum;
+    for (const val of arr) {
+        head.next = new ListNode(val);
+        head = head.next;
+    }
+    return dum.next;
+}
+
+module.exports = {
+    ListNode,
+    arrToLinkedList,
+};

ru/codes/javascript/modules/PrintUtil.js

@@ -0,0 +1,86 @@
+/**
+ * File: PrintUtil.js
+ * Created Time: 2022-12-04
+ * Author: IsChristina (christinaxia77@foxmail.com)
+ */
+
+const { arrToTree } = require('./TreeNode');
+
+/* Вывести связный список */
+function printLinkedList(head) {
+    let list = [];
+    while (head !== null) {
+        list.push(head.val.toString());
+        head = head.next;
+    }
+    console.log(list.join(' -> '));
+}
+
+function Trunk(prev, str) {
+    this.prev = prev;
+    this.str = str;
+}
+
+/**
+ * Вывести двоичное дерево
+ * Этот вывод дерева заимствован из TECHIE DELIGHT
+ * https://www.techiedelight.com/c-program-print-binary-tree/
+ */
+function printTree(root) {
+    printTree(root, null, false);
+}
+
+/* Вывести двоичное дерево */
+function printTree(root, prev, isRight) {
+    if (root === null) {
+        return;
+    }
+
+    let prev_str = '    ';
+    let trunk = new Trunk(prev, prev_str);
+
+    printTree(root.right, trunk, true);
+
+    if (!prev) {
+        trunk.str = '———';
+    } else if (isRight) {
+        trunk.str = '/———';
+        prev_str = '   |';
+    } else {
+        trunk.str = '\\———';
+        prev.str = prev_str;
+    }
+
+    showTrunks(trunk);
+    console.log(' ' + root.val);
+
+    if (prev) {
+        prev.str = prev_str;
+    }
+    trunk.str = '   |';
+
+    printTree(root.left, trunk, false);
+}
+
+function showTrunks(p) {
+    if (!p) {
+        return;
+    }
+
+    showTrunks(p.prev);
+    process.stdout.write(p.str);
+}
+
+/* Вывести кучу */
+function printHeap(arr) {
+    console.log('Массивное представление кучи:');
+    console.log(arr);
+    console.log('Древовидное представление кучи:');
+    printTree(arrToTree(arr));
+}
+
+module.exports = {
+    printLinkedList,
+    printTree,
+    printHeap,
+};

ru/codes/javascript/modules/TreeNode.js

@@ -0,0 +1,35 @@
+/**
+ * File: TreeNode.js
+ * Created Time: 2022-12-04
+ * Author: IsChristina (christinaxia77@foxmail.com)
+ */
+
+/* Узел двоичного дерева */
+class TreeNode {
+    val; // Значение узла
+    left; // Указатель на левый дочерний узел
+    right; // Указатель на правый дочерний узел
+    height; // Высота узла
+    constructor(val, left, right, height) {
+        this.val = val === undefined ? 0 : val;
+        this.left = left === undefined ? null : left;
+        this.right = right === undefined ? null : right;
+        this.height = height === undefined ? 0 : height;
+    }
+}
+
+/* Десериализовать массив в двоичное дерево */
+function arrToTree(arr, i = 0) {
+    if (i < 0 || i >= arr.length || arr[i] === null) {
+        return null;
+    }
+    let root = new TreeNode(arr[i]);
+    root.left = arrToTree(arr, 2 * i + 1);
+    root.right = arrToTree(arr, 2 * i + 2);
+    return root;
+}
+
+module.exports = {
+    TreeNode,
+    arrToTree,
+};

ru/codes/javascript/modules/Vertex.js

@@ -0,0 +1,35 @@
+/**
+ * File: Vertex.js
+ * Created Time: 2023-02-15
+ * Author: Zhuo Qinyue (1403450829@qq.com)
+ */
+
+/* Класс вершины */
+class Vertex {
+    val;
+    constructor(val) {
+        this.val = val;
+    }
+
+    /* На вход подается список значений vals, на выходе возвращается список вершин vets */
+    static valsToVets(vals) {
+        const vets = [];
+        for (let i = 0; i < vals.length; i++) {
+            vets[i] = new Vertex(vals[i]);
+        }
+        return vets;
+    }
+
+    /* На вход подается список вершин vets, на выходе возвращается список значений vals */
+    static vetsToVals(vets) {
+        const vals = [];
+        for (const vet of vets) {
+            vals.push(vet.val);
+        }
+        return vals;
+    }
+}
+
+module.exports = {
+    Vertex,
+};

ru/codes/javascript/test_all.js

@@ -0,0 +1,63 @@
+import { bold, brightRed } from 'jsr:@std/fmt/colors';
+import { expandGlob } from 'jsr:@std/fs';
+import { relative, resolve } from 'jsr:@std/path';
+
+/**
+ * @typedef {import('jsr:@std/fs').WalkEntry} WalkEntry
+ * @type {WalkEntry[]}
+ */
+const entries = [];
+
+for await (const entry of expandGlob(
+    resolve(import.meta.dirname, './chapter_*/*.js')
+)) {
+    entries.push(entry);
+}
+
+/** @type {{ status: Promise<Deno.CommandStatus>; stderr: ReadableStream<Uint8Array>; }[]} */
+const processes = [];
+
+for (const file of entries) {
+    const execute = new Deno.Command('node', {
+        args: [relative(import.meta.dirname, file.path)],
+        cwd: import.meta.dirname,
+        stdin: 'piped',
+        stdout: 'piped',
+        stderr: 'piped',
+    });
+
+    const process = execute.spawn();
+    processes.push({ status: process.status, stderr: process.stderr });
+}
+
+const results = await Promise.all(
+    processes.map(async (item) => {
+        const status = await item.status;
+        return { status, stderr: item.stderr };
+    })
+);
+
+/** @type {ReadableStream<Uint8Array>[]} */
+const errors = [];
+
+for (const result of results) {
+    if (!result.status.success) {
+        errors.push(result.stderr);
+    }
+}
+
+console.log(`Tested ${entries.length} files`);
+console.log(`Found exception in ${errors.length} files`);
+
+if (errors.length) {
+    console.log();
+
+    for (const error of errors) {
+        const reader = error.getReader();
+        const { value } = await reader.read();
+        const decoder = new TextDecoder();
+        console.log(`${bold(brightRed('error'))}: ${decoder.decode(value)}`);
+    }
+
+    throw new Error('Test failed');
+}