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-08-14 20:50:58 +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,51 @@
+/**
+ * File: bubble_sort.swift
+ * Created Time: 2023-01-29
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+/* Пузырьковая сортировка */
+func bubbleSort(nums: inout [Int]) {
+    // Внешний цикл: неотсортированный диапазон [0, i]
+    for i in nums.indices.dropFirst().reversed() {
+        // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
+        for j in 0 ..< i {
+            if nums[j] > nums[j + 1] {
+                // Поменять местами nums[j] и nums[j + 1]
+                nums.swapAt(j, j + 1)
+            }
+        }
+    }
+}
+
+/* Пузырьковая сортировка (оптимизация флагом) */
+func bubbleSortWithFlag(nums: inout [Int]) {
+    // Внешний цикл: неотсортированный диапазон [0, i]
+    for i in nums.indices.dropFirst().reversed() {
+        var flag = false // Инициализировать флаг
+        for j in 0 ..< i {
+            if nums[j] > nums[j + 1] {
+                // Поменять местами nums[j] и nums[j + 1]
+                nums.swapAt(j, j + 1)
+                flag = true // Записать обмен элементов
+            }
+        }
+        if !flag { // На этой итерации «всплытия» не было ни одного обмена, сразу выйти
+            break
+        }
+    }
+}
+
+@main
+enum BubbleSort {
+    /* Driver Code */
+    static func main() {
+        var nums = [4, 1, 3, 1, 5, 2]
+        bubbleSort(nums: &nums)
+        print("После пузырьковой сортировки nums = \(nums)")
+
+        var nums1 = [4, 1, 3, 1, 5, 2]
+        bubbleSortWithFlag(nums: &nums1)
+        print("После пузырьковой сортировки nums1 = \(nums1)")
+    }
+}
@@ -0,0 +1,43 @@
+/**
+ * File: bucket_sort.swift
+ * Created Time: 2023-03-27
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+/* Сортировка корзинами */
+func bucketSort(nums: inout [Double]) {
+    // Инициализировать k = n/2 корзин, предполагая распределение 2 элементов в каждую корзину
+    let k = nums.count / 2
+    var buckets = (0 ..< k).map { _ in [Double]() }
+    // 1. Распределить элементы массива по корзинам
+    for num in nums {
+        // Входные данные лежат в диапазоне [0, 1); использовать num * k для отображения в диапазон индексов [0, k-1]
+        let i = Int(num * Double(k))
+        // Добавить num в корзину i
+        buckets[i].append(num)
+    }
+    // 2. Выполнить сортировку внутри каждой корзины
+    for i in buckets.indices {
+        // Использовать встроенную функцию сортировки; ее также можно заменить другим алгоритмом сортировки
+        buckets[i].sort()
+    }
+    // 3. Обойти корзины и объединить результаты
+    var i = nums.startIndex
+    for bucket in buckets {
+        for num in bucket {
+            nums[i] = num
+            i += 1
+        }
+    }
+}
+
+@main
+enum BucketSort {
+    /* Driver Code */
+    static func main() {
+        // Пусть входные данные — числа с плавающей точкой из диапазона [0, 1)
+        var nums = [0.49, 0.96, 0.82, 0.09, 0.57, 0.43, 0.91, 0.75, 0.15, 0.37]
+        bucketSort(nums: &nums)
+        print("После сортировки корзинами nums = \(nums)")
+    }
+}
@@ -0,0 +1,70 @@
+/**
+ * File: counting_sort.swift
+ * Created Time: 2023-03-22
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+/* Сортировка подсчетом */
+// Простая реализация, не подходит для сортировки объектов
+func countingSortNaive(nums: inout [Int]) {
+    // 1. Найти максимальный элемент массива m
+    let m = nums.max()!
+    // 2. Подсчитать число появлений каждой цифры
+    // counter[num] обозначает число появлений num
+    var counter = Array(repeating: 0, count: m + 1)
+    for num in nums {
+        counter[num] += 1
+    }
+    // 3. Обойти counter и заполнить исходный массив nums элементами
+    var i = 0
+    for num in 0 ..< m + 1 {
+        for _ in 0 ..< counter[num] {
+            nums[i] = num
+            i += 1
+        }
+    }
+}
+
+/* Сортировка подсчетом */
+// Полная реализация, позволяет сортировать объекты и является стабильной сортировкой
+func countingSort(nums: inout [Int]) {
+    // 1. Найти максимальный элемент массива m
+    let m = nums.max()!
+    // 2. Подсчитать число появлений каждой цифры
+    // counter[num] обозначает число появлений num
+    var counter = Array(repeating: 0, count: m + 1)
+    for num in nums {
+        counter[num] += 1
+    }
+    // 3. Вычислить префиксные суммы counter и преобразовать «число появлений» в «конечный индекс»
+    // То есть counter[num]-1 — это индекс последнего появления num в res
+    for i in 0 ..< m {
+        counter[i + 1] += counter[i]
+    }
+    // 4. Обойти nums в обратном порядке и поместить элементы в результирующий массив res
+    // Инициализировать массив res для хранения результата
+    var res = Array(repeating: 0, count: nums.count)
+    for i in nums.indices.reversed() {
+        let num = nums[i]
+        res[counter[num] - 1] = num // Поместить num по соответствующему индексу
+        counter[num] -= 1 // Уменьшить префиксную сумму на 1, чтобы получить индекс следующего размещения num
+    }
+    // Перезаписать исходный массив nums массивом результата res
+    for i in nums.indices {
+        nums[i] = res[i]
+    }
+}
+
+@main
+enum CountingSort {
+    /* Driver Code */
+    static func main() {
+        var nums = [1, 0, 1, 2, 0, 4, 0, 2, 2, 4]
+        countingSortNaive(nums: &nums)
+        print("После сортировки подсчетом (объекты не поддерживаются) nums = \(nums)")
+
+        var nums1 = [1, 0, 1, 2, 0, 4, 0, 2, 2, 4]
+        countingSort(nums: &nums1)
+        print("После сортировки подсчетом nums1 = \(nums1)")
+    }
+}
@@ -0,0 +1,55 @@
+/**
+ * File: heap_sort.swift
+ * Created Time: 2023-05-28
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+/* Длина кучи равна n; начиная с узла i, выполнить просеивание сверху вниз */
+func siftDown(nums: inout [Int], n: Int, i: Int) {
+    var i = i
+    while true {
+        // Определить узел с максимальным значением среди i, l и r и обозначить его как ma
+        let l = 2 * i + 1
+        let r = 2 * i + 2
+        var 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.swapAt(i, ma)
+        // Циклическое просеивание вниз
+        i = ma
+    }
+}
+
+/* Сортировка кучей */
+func heapSort(nums: inout [Int]) {
+    // Построение кучи: выполнить heapify для всех узлов, кроме листовых
+    for i in stride(from: nums.count / 2 - 1, through: 0, by: -1) {
+        siftDown(nums: &nums, n: nums.count, i: i)
+    }
+    // Извлекать максимальный элемент из кучи в течение n-1 итераций
+    for i in nums.indices.dropFirst().reversed() {
+        // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)
+        nums.swapAt(0, i)
+        // Начиная с корневого узла, выполнить просеивание сверху вниз
+        siftDown(nums: &nums, n: i, i: 0)
+    }
+}
+
+@main
+enum HeapSort {
+    /* Driver Code */
+    static func main() {
+        var nums = [4, 1, 3, 1, 5, 2]
+        heapSort(nums: &nums)
+        print("После сортировки кучей nums = \(nums)")
+    }
+}
@@ -0,0 +1,30 @@
+/**
+ * File: insertion_sort.swift
+ * Created Time: 2023-01-29
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+/* Сортировка вставками */
+func insertionSort(nums: inout [Int]) {
+    // Внешний цикл: отсортированный диапазон [0, i-1]
+    for i in nums.indices.dropFirst() {
+        let base = nums[i]
+        var j = i - 1
+        // Внутренний цикл: вставить base в правильную позицию отсортированного диапазона [0, i-1]
+        while j >= 0, nums[j] > base {
+            nums[j + 1] = nums[j] // Сдвинуть nums[j] на одну позицию вправо
+            j -= 1
+        }
+        nums[j + 1] = base // Поместить base в правильную позицию
+    }
+}
+
+@main
+enum InsertionSort {
+    /* Driver Code */
+    static func main() {
+        var nums = [4, 1, 3, 1, 5, 2]
+        insertionSort(nums: &nums)
+        print("После сортировки вставками nums = \(nums)")
+    }
+}
@@ -0,0 +1,65 @@
+/**
+ * File: merge_sort.swift
+ * Created Time: 2023-01-29
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+/* Объединить левый и правый подмассивы */
+func merge(nums: inout [Int], left: Int, mid: Int, right: Int) {
+    // Диапазон левого подмассива: [left, mid], диапазон правого подмассива: [mid+1, right]
+    // Создать временный массив tmp для хранения результата слияния
+    var tmp = Array(repeating: 0, count: right - left + 1)
+    // Инициализировать начальные индексы левого и правого подмассивов
+    var i = left, j = mid + 1, k = 0
+    // Пока в левом и правом подмассивах еще есть элементы, сравнивать их и копировать меньший во временный массив
+    while i <= mid, j <= right {
+        if nums[i] <= nums[j] {
+            tmp[k] = nums[i]
+            i += 1
+        } else {
+            tmp[k] = nums[j]
+            j += 1
+        }
+        k += 1
+    }
+    // Скопировать оставшиеся элементы левого и правого подмассивов во временный массив
+    while i <= mid {
+        tmp[k] = nums[i]
+        i += 1
+        k += 1
+    }
+    while j <= right {
+        tmp[k] = nums[j]
+        j += 1
+        k += 1
+    }
+    // Скопировать элементы временного массива tmp обратно в соответствующий диапазон исходного массива nums
+    for k in tmp.indices {
+        nums[left + k] = tmp[k]
+    }
+}
+
+/* Сортировка слиянием */
+func mergeSort(nums: inout [Int], left: Int, right: Int) {
+    // Условие завершения
+    if left >= right { // Завершить рекурсию, когда длина подмассива равна 1
+        return
+    }
+    // Этап разбиения
+    let mid = left + (right - left) / 2 // Вычислить середину
+    mergeSort(nums: &nums, left: left, right: mid) // Рекурсивно обработать левый подмассив
+    mergeSort(nums: &nums, left: mid + 1, right: right) // Рекурсивно обработать правый подмассив
+    // Этап слияния
+    merge(nums: &nums, left: left, mid: mid, right: right)
+}
+
+@main
+enum MergeSort {
+    /* Driver Code */
+    static func main() {
+        /* Сортировка слиянием */
+        var nums = [7, 3, 2, 6, 0, 1, 5, 4]
+        mergeSort(nums: &nums, left: nums.startIndex, right: nums.endIndex - 1)
+        print("После сортировки слиянием nums = \(nums)")
+    }
+}
@@ -0,0 +1,114 @@
+/**
+ * File: quick_sort.swift
+ * Created Time: 2023-01-29
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+/* Класс быстрой сортировки */
+/* Разбиение с опорными указателями */
+func partition(nums: inout [Int], left: Int, right: Int) -> Int {
+    // Взять nums[left] в качестве опорного элемента
+    var i = left
+    var j = right
+    while i < j {
+        while i < j, nums[j] >= nums[left] {
+            j -= 1 // Идти справа налево в поисках первого элемента меньше опорного
+        }
+        while i < j, nums[i] <= nums[left] {
+            i += 1 // Идти слева направо в поисках первого элемента больше опорного
+        }
+        nums.swapAt(i, j) // Поменять эти два элемента местами
+    }
+    nums.swapAt(i, left) // Переместить опорный элемент на границу двух подмассивов
+    return i // Вернуть индекс опорного элемента
+}
+
+/* Быстрая сортировка */
+func quickSort(nums: inout [Int], left: Int, right: Int) {
+    // Завершить рекурсию, когда длина подмассива равна 1
+    if left >= right {
+        return
+    }
+    // Разбиение с опорными указателями
+    let pivot = partition(nums: &nums, left: left, right: right)
+    // Рекурсивно обработать левый и правый подмассивы
+    quickSort(nums: &nums, left: left, right: pivot - 1)
+    quickSort(nums: &nums, left: pivot + 1, right: right)
+}
+
+/* Класс быстрой сортировки (оптимизация медианным опорным элементом) */
+/* Выбрать медиану из трех кандидатов */
+func medianThree(nums: [Int], left: Int, mid: Int, right: Int) -> Int {
+    let l = nums[left]
+    let m = nums[mid]
+    let r = nums[right]
+    if (l <= m && m <= r) || (r <= m && m <= l) {
+        return mid // m находится между l и r
+    }
+    if (m <= l && l <= r) || (r <= l && l <= m) {
+        return left // l находится между m и r
+    }
+    return right
+}
+
+/* Разбиение с опорными указателями (медиана трех) */
+func partitionMedian(nums: inout [Int], left: Int, right: Int) -> Int {
+    // Выбрать медиану из трех кандидатов
+    let med = medianThree(nums: nums, left: left, mid: left + (right - left) / 2, right: right)
+    // Переместить медиану в крайний левый элемент массива
+    nums.swapAt(left, med)
+    return partition(nums: &nums, left: left, right: right)
+}
+
+/* Быстрая сортировка (оптимизация медианным опорным элементом) */
+func quickSortMedian(nums: inout [Int], left: Int, right: Int) {
+    // Завершить рекурсию, когда длина подмассива равна 1
+    if left >= right {
+        return
+    }
+    // Разбиение с опорными указателями
+    let pivot = partitionMedian(nums: &nums, left: left, right: right)
+    // Рекурсивно обработать левый и правый подмассивы
+    quickSortMedian(nums: &nums, left: left, right: pivot - 1)
+    quickSortMedian(nums: &nums, left: pivot + 1, right: right)
+}
+
+/* Быстрая сортировка (оптимизация глубины рекурсии) */
+func quickSortTailCall(nums: inout [Int], left: Int, right: Int) {
+    var left = left
+    var right = right
+    // Завершить, когда длина подмассива равна 1
+    while left < right {
+        // Операция разбиения с опорными указателями
+        let pivot = partition(nums: &nums, left: left, right: right)
+        // Выполнить быструю сортировку для более короткого из двух подмассивов
+        if (pivot - left) < (right - pivot) {
+            quickSortTailCall(nums: &nums, left: left, right: pivot - 1) // Рекурсивно отсортировать левый подмассив
+            left = pivot + 1 // Оставшийся неотсортированный диапазон: [pivot + 1, right]
+        } else {
+            quickSortTailCall(nums: &nums, left: pivot + 1, right: right) // Рекурсивно отсортировать правый подмассив
+            right = pivot - 1 // Оставшийся неотсортированный диапазон: [left, pivot - 1]
+        }
+    }
+}
+
+@main
+enum QuickSort {
+    /* Driver Code */
+    static func main() {
+        /* Быстрая сортировка */
+        var nums = [2, 4, 1, 0, 3, 5]
+        quickSort(nums: &nums, left: nums.startIndex, right: nums.endIndex - 1)
+        print("После быстрой сортировки nums = \(nums)")
+
+        /* Быстрая сортировка (оптимизация медианным опорным элементом) */
+        var nums1 = [2, 4, 1, 0, 3, 5]
+        quickSortMedian(nums: &nums1, left: nums1.startIndex, right: nums1.endIndex - 1)
+        print("После быстрой сортировки (оптимизация медианным опорным элементом) nums1 = \(nums1)")
+
+        /* Быстрая сортировка (оптимизация глубины рекурсии) */
+        var nums2 = [2, 4, 1, 0, 3, 5]
+        quickSortTailCall(nums: &nums2, left: nums2.startIndex, right: nums2.endIndex - 1)
+        print("После быстрой сортировки (оптимизация глубины рекурсии) nums2 = \(nums2)")
+    }
+}
@@ -0,0 +1,79 @@
+/**
+ * File: radix_sort.swift
+ * Created Time: 2023-01-29
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+/* Получить k-й разряд элемента num, где exp = 10^(k-1) */
+func digit(num: Int, exp: Int) -> Int {
+    // Передача exp вместо k позволяет избежать повторного дорогостоящего вычисления степени
+    (num / exp) % 10
+}
+
+/* Сортировка подсчетом (сортировка по k-му разряду nums) */
+func countingSortDigit(nums: inout [Int], exp: Int) {
+    // Разряды десятичной системы лежат в диапазоне 0~9, поэтому нужен массив корзин длины 10
+    var counter = Array(repeating: 0, count: 10)
+    // Подсчитать число появлений каждой цифры от 0 до 9
+    for i in nums.indices {
+        let d = digit(num: nums[i], exp: exp) // Получить k-й разряд nums[i], обозначив его как d
+        counter[d] += 1 // Подсчитать число появлений цифры d
+    }
+    // Вычислить префиксные суммы и преобразовать «число появлений» в «индекс массива»
+    for i in 1 ..< 10 {
+        counter[i] += counter[i - 1]
+    }
+    // Выполняя обратный проход, заполнить res элементами по статистике в корзинах
+    var res = Array(repeating: 0, count: nums.count)
+    for i in nums.indices.reversed() {
+        let d = digit(num: nums[i], exp: exp)
+        let j = counter[d] - 1 // Получить индекс j цифры d в массиве
+        res[j] = nums[i] // Поместить текущий элемент по индексу j
+        counter[d] -= 1 // Уменьшить количество d на 1
+    }
+    // Перезаписать исходный массив nums результатом
+    for i in nums.indices {
+        nums[i] = res[i]
+    }
+}
+
+/* Поразрядная сортировка */
+func radixSort(nums: inout [Int]) {
+    // Получить максимальный элемент массива, чтобы определить максимальное число разрядов
+    var m = Int.min
+    for num in nums {
+        if num > m {
+            m = num
+        }
+    }
+    // Проходить разряды от младшего к старшему
+    for exp in sequence(first: 1, next: { m >= ($0 * 10) ? $0 * 10 : nil }) {
+        // Выполнить сортировку подсчетом по k-му разряду элементов массива
+        // k = 1 -> exp = 1
+        // k = 2 -> exp = 10
+        // то есть exp = 10^(k-1)
+        countingSortDigit(nums: &nums, exp: exp)
+    }
+}
+
+@main
+enum RadixSort {
+    /* Driver Code */
+    static func main() {
+        // Поразрядная сортировка
+        var nums = [
+            10_546_151,
+            35_663_510,
+            42_865_989,
+            34_862_445,
+            81_883_077,
+            88_906_420,
+            72_429_244,
+            30_524_779,
+            82_060_337,
+            63_832_996,
+        ]
+        radixSort(nums: &nums)
+        print("После поразрядной сортировки nums = \(nums)")
+    }
+}
@@ -0,0 +1,31 @@
+/**
+ * File: selection_sort.swift
+ * Created Time: 2023-05-28
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+/* Сортировка выбором */
+func selectionSort(nums: inout [Int]) {
+    // Внешний цикл: неотсортированный диапазон [i, n-1]
+    for i in nums.indices.dropLast() {
+        // Внутренний цикл: найти минимальный элемент в неотсортированном диапазоне
+        var k = i
+        for j in nums.indices.dropFirst(i + 1) {
+            if nums[j] < nums[k] {
+                k = j // Записать индекс минимального элемента
+            }
+        }
+        // Поменять этот минимальный элемент местами с первым элементом неотсортированного диапазона
+        nums.swapAt(i, k)
+    }
+}
+
+@main
+enum SelectionSort {
+    /* Driver Code */
+    static func main() {
+        var nums = [4, 1, 3, 1, 5, 2]
+        selectionSort(nums: &nums)
+        print("После сортировки выбором nums = \(nums)")
+    }
+}