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
2026-07-04 11:44:21 +00:00 · 2026-03-28 04:24:07 +08:00
parent 2ca570cc33
commit 772183705e
1958 changed files with 108186 additions and 0 deletions
@@ -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}`);
@@ -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}`);
+
@@ -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);
@@ -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);
@@ -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);
+}