mirror of
https://github.com/krahets/hello-algo.git
synced 2026-07-12 23:36:06 +00:00
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
This commit is contained in:
Yudong Jin
@@ -0,0 +1,51 @@
|
||||
/**
|
||||
* File: bubble_sort.cs
|
||||
* Created Time: 2022-12-23
|
||||
* Author: haptear (haptear@hotmail.com)
|
||||
*/
|
||||
|
||||
namespace hello_algo.chapter_sorting;
|
||||
|
||||
public class bubble_sort {
|
||||
/* Пузырьковая сортировка */
|
||||
void BubbleSort(int[] nums) {
|
||||
// Внешний цикл: неотсортированный диапазон [0, i]
|
||||
for (int i = nums.Length - 1; i > 0; i--) {
|
||||
// Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
|
||||
for (int j = 0; j < i; j++) {
|
||||
if (nums[j] > nums[j + 1]) {
|
||||
// Поменять местами nums[j] и nums[j + 1]
|
||||
(nums[j + 1], nums[j]) = (nums[j], nums[j + 1]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Пузырьковая сортировка (оптимизация флагом) */
|
||||
void BubbleSortWithFlag(int[] nums) {
|
||||
// Внешний цикл: неотсортированный диапазон [0, i]
|
||||
for (int i = nums.Length - 1; i > 0; i--) {
|
||||
bool flag = false; // Инициализировать флаг
|
||||
// Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
|
||||
for (int j = 0; j < i; j++) {
|
||||
if (nums[j] > nums[j + 1]) {
|
||||
// Поменять местами nums[j] и nums[j + 1]
|
||||
(nums[j + 1], nums[j]) = (nums[j], nums[j + 1]);
|
||||
flag = true; // Записать обмен элементов
|
||||
}
|
||||
}
|
||||
if (!flag) break; // На этой итерации «всплытия» не было ни одного обмена, сразу выйти
|
||||
}
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Test() {
|
||||
int[] nums = [4, 1, 3, 1, 5, 2];
|
||||
BubbleSort(nums);
|
||||
Console.WriteLine("После пузырьковой сортировки nums = " + string.Join(",", nums));
|
||||
|
||||
int[] nums1 = [4, 1, 3, 1, 5, 2];
|
||||
BubbleSortWithFlag(nums1);
|
||||
Console.WriteLine("После пузырьковой сортировки nums1 = " + string.Join(",", nums1));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,46 @@
|
||||
/**
|
||||
* File: bucket_sort.cs
|
||||
* Created Time: 2023-04-13
|
||||
* Author: hpstory (hpstory1024@163.com)
|
||||
*/
|
||||
|
||||
namespace hello_algo.chapter_sorting;
|
||||
|
||||
public class bucket_sort {
|
||||
/* Сортировка корзинами */
|
||||
void BucketSort(float[] nums) {
|
||||
// Инициализировать k = n/2 корзин, предполагая распределение 2 элементов в каждую корзину
|
||||
int k = nums.Length / 2;
|
||||
List<List<float>> buckets = [];
|
||||
for (int i = 0; i < k; i++) {
|
||||
buckets.Add([]);
|
||||
}
|
||||
// 1. Распределить элементы массива по корзинам
|
||||
foreach (float num in nums) {
|
||||
// Входные данные лежат в диапазоне [0, 1); использовать num * k для отображения в диапазон индексов [0, k-1]
|
||||
int i = (int)(num * k);
|
||||
// Добавить num в корзину i
|
||||
buckets[i].Add(num);
|
||||
}
|
||||
// 2. Выполнить сортировку внутри каждой корзины
|
||||
foreach (List<float> bucket in buckets) {
|
||||
// Использовать встроенную функцию сортировки; ее также можно заменить другим алгоритмом сортировки
|
||||
bucket.Sort();
|
||||
}
|
||||
// 3. Обойти корзины и объединить результаты
|
||||
int j = 0;
|
||||
foreach (List<float> bucket in buckets) {
|
||||
foreach (float num in bucket) {
|
||||
nums[j++] = num;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Test() {
|
||||
// Пусть входные данные — числа с плавающей точкой из диапазона [0, 1)
|
||||
float[] nums = [0.49f, 0.96f, 0.82f, 0.09f, 0.57f, 0.43f, 0.91f, 0.75f, 0.15f, 0.37f];
|
||||
BucketSort(nums);
|
||||
Console.WriteLine("После сортировки корзинами nums = " + string.Join(" ", nums));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,77 @@
|
||||
/**
|
||||
* File: counting_sort.cs
|
||||
* Created Time: 2023-04-13
|
||||
* Author: hpstory (hpstory1024@163.com)
|
||||
*/
|
||||
|
||||
namespace hello_algo.chapter_sorting;
|
||||
|
||||
public class counting_sort {
|
||||
/* Сортировка подсчетом */
|
||||
// Простая реализация, не подходит для сортировки объектов
|
||||
void CountingSortNaive(int[] nums) {
|
||||
// 1. Найти максимальный элемент массива m
|
||||
int m = 0;
|
||||
foreach (int num in nums) {
|
||||
m = Math.Max(m, num);
|
||||
}
|
||||
// 2. Подсчитать число появлений каждой цифры
|
||||
// counter[num] обозначает число появлений num
|
||||
int[] counter = new int[m + 1];
|
||||
foreach (int num in nums) {
|
||||
counter[num]++;
|
||||
}
|
||||
// 3. Обойти counter и заполнить исходный массив nums элементами
|
||||
int i = 0;
|
||||
for (int num = 0; num < m + 1; num++) {
|
||||
for (int j = 0; j < counter[num]; j++, i++) {
|
||||
nums[i] = num;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Сортировка подсчетом */
|
||||
// Полная реализация, позволяет сортировать объекты и является стабильной сортировкой
|
||||
void CountingSort(int[] nums) {
|
||||
// 1. Найти максимальный элемент массива m
|
||||
int m = 0;
|
||||
foreach (int num in nums) {
|
||||
m = Math.Max(m, num);
|
||||
}
|
||||
// 2. Подсчитать число появлений каждой цифры
|
||||
// counter[num] обозначает число появлений num
|
||||
int[] counter = new int[m + 1];
|
||||
foreach (int num in nums) {
|
||||
counter[num]++;
|
||||
}
|
||||
// 3. Вычислить префиксные суммы counter и преобразовать «число появлений» в «конечный индекс»
|
||||
// То есть counter[num]-1 — это индекс последнего появления num в res
|
||||
for (int i = 0; i < m; i++) {
|
||||
counter[i + 1] += counter[i];
|
||||
}
|
||||
// 4. Обойти nums в обратном порядке и поместить элементы в результирующий массив res
|
||||
// Инициализировать массив res для хранения результата
|
||||
int n = nums.Length;
|
||||
int[] res = new int[n];
|
||||
for (int i = n - 1; i >= 0; i--) {
|
||||
int num = nums[i];
|
||||
res[counter[num] - 1] = num; // Поместить num по соответствующему индексу
|
||||
counter[num]--; // Уменьшить префиксную сумму на 1, чтобы получить индекс следующего размещения num
|
||||
}
|
||||
// Перезаписать исходный массив nums массивом результата res
|
||||
for (int i = 0; i < n; i++) {
|
||||
nums[i] = res[i];
|
||||
}
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Test() {
|
||||
int[] nums = [1, 0, 1, 2, 0, 4, 0, 2, 2, 4];
|
||||
CountingSortNaive(nums);
|
||||
Console.WriteLine("После сортировки подсчетом (объекты не поддерживаются) nums = " + string.Join(" ", nums));
|
||||
|
||||
int[] nums1 = [1, 0, 1, 2, 0, 4, 0, 2, 2, 4];
|
||||
CountingSort(nums1);
|
||||
Console.WriteLine("После сортировки подсчетом nums1 = " + string.Join(" ", nums));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,52 @@
|
||||
/**
|
||||
* File: heap_sort.cs
|
||||
* Created Time: 2023-06-01
|
||||
* Author: hpstory (hpstory1024@163.com)
|
||||
*/
|
||||
|
||||
namespace hello_algo.chapter_sorting;
|
||||
|
||||
public class heap_sort {
|
||||
/* Длина кучи равна n; начиная с узла i, выполнить просеивание сверху вниз */
|
||||
void SiftDown(int[] nums, int n, int i) {
|
||||
while (true) {
|
||||
// Определить узел с максимальным значением среди i, l и r и обозначить его как ma
|
||||
int l = 2 * i + 1;
|
||||
int r = 2 * i + 2;
|
||||
int ma = i;
|
||||
if (l < n && nums[l] > nums[ma])
|
||||
ma = l;
|
||||
if (r < n && nums[r] > nums[ma])
|
||||
ma = r;
|
||||
// Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти
|
||||
if (ma == i)
|
||||
break;
|
||||
// Поменять два узла местами
|
||||
(nums[ma], nums[i]) = (nums[i], nums[ma]);
|
||||
// Циклическое просеивание вниз
|
||||
i = ma;
|
||||
}
|
||||
}
|
||||
|
||||
/* Сортировка кучей */
|
||||
void HeapSort(int[] nums) {
|
||||
// Построение кучи: выполнить heapify для всех узлов, кроме листовых
|
||||
for (int i = nums.Length / 2 - 1; i >= 0; i--) {
|
||||
SiftDown(nums, nums.Length, i);
|
||||
}
|
||||
// Извлекать максимальный элемент из кучи в течение n-1 итераций
|
||||
for (int i = nums.Length - 1; i > 0; i--) {
|
||||
// Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)
|
||||
(nums[i], nums[0]) = (nums[0], nums[i]);
|
||||
// Начиная с корневого узла, выполнить просеивание сверху вниз
|
||||
SiftDown(nums, i, 0);
|
||||
}
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Test() {
|
||||
int[] nums = [4, 1, 3, 1, 5, 2];
|
||||
HeapSort(nums);
|
||||
Console.WriteLine("После сортировки кучей nums = " + string.Join(" ", nums));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,30 @@
|
||||
/**
|
||||
* File: insertion_sort.cs
|
||||
* Created Time: 2022-12-23
|
||||
* Author: haptear (haptear@hotmail.com)
|
||||
*/
|
||||
|
||||
namespace hello_algo.chapter_sorting;
|
||||
|
||||
public class insertion_sort {
|
||||
/* Сортировка вставками */
|
||||
void InsertionSort(int[] nums) {
|
||||
// Внешний цикл: отсортированный диапазон [0, i-1]
|
||||
for (int i = 1; i < nums.Length; i++) {
|
||||
int bas = nums[i], j = i - 1;
|
||||
// Внутренний цикл: вставить base в правильную позицию отсортированного диапазона [0, i-1]
|
||||
while (j >= 0 && nums[j] > bas) {
|
||||
nums[j + 1] = nums[j]; // Сдвинуть nums[j] на одну позицию вправо
|
||||
j--;
|
||||
}
|
||||
nums[j + 1] = bas; // Поместить base в правильную позицию
|
||||
}
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Test() {
|
||||
int[] nums = [4, 1, 3, 1, 5, 2];
|
||||
InsertionSort(nums);
|
||||
Console.WriteLine("После сортировки вставками nums = " + string.Join(",", nums));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,56 @@
|
||||
/**
|
||||
* File: merge_sort.cs
|
||||
* Created Time: 2022-12-23
|
||||
* Author: haptear (haptear@hotmail.com)
|
||||
*/
|
||||
|
||||
namespace hello_algo.chapter_sorting;
|
||||
|
||||
public class merge_sort {
|
||||
/* Объединить левый и правый подмассивы */
|
||||
void Merge(int[] nums, int left, int mid, int right) {
|
||||
// Диапазон левого подмассива: [left, mid], диапазон правого подмассива: [mid+1, right]
|
||||
// Создать временный массив tmp для хранения результата слияния
|
||||
int[] tmp = new int[right - left + 1];
|
||||
// Инициализировать начальные индексы левого и правого подмассивов
|
||||
int i = left, j = mid + 1, k = 0;
|
||||
// Пока в левом и правом подмассивах еще есть элементы, сравнивать их и копировать меньший во временный массив
|
||||
while (i <= mid && j <= right) {
|
||||
if (nums[i] <= nums[j])
|
||||
tmp[k++] = nums[i++];
|
||||
else
|
||||
tmp[k++] = nums[j++];
|
||||
}
|
||||
// Скопировать оставшиеся элементы левого и правого подмассивов во временный массив
|
||||
while (i <= mid) {
|
||||
tmp[k++] = nums[i++];
|
||||
}
|
||||
while (j <= right) {
|
||||
tmp[k++] = nums[j++];
|
||||
}
|
||||
// Скопировать элементы временного массива tmp обратно в соответствующий диапазон исходного массива nums
|
||||
for (k = 0; k < tmp.Length; ++k) {
|
||||
nums[left + k] = tmp[k];
|
||||
}
|
||||
}
|
||||
|
||||
/* Сортировка слиянием */
|
||||
void MergeSort(int[] nums, int left, int right) {
|
||||
// Условие завершения
|
||||
if (left >= right) return; // Завершить рекурсию, когда длина подмассива равна 1
|
||||
// Этап разбиения
|
||||
int mid = left + (right - left) / 2; // Вычислить середину
|
||||
MergeSort(nums, left, mid); // Рекурсивно обработать левый подмассив
|
||||
MergeSort(nums, mid + 1, right); // Рекурсивно обработать правый подмассив
|
||||
// Этап слияния
|
||||
Merge(nums, left, mid, right);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Test() {
|
||||
/* Сортировка слиянием */
|
||||
int[] nums = [7, 3, 2, 6, 0, 1, 5, 4];
|
||||
MergeSort(nums, 0, nums.Length - 1);
|
||||
Console.WriteLine("После сортировки слиянием nums = " + string.Join(",", nums));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,150 @@
|
||||
/**
|
||||
* File: quick_sort.cs
|
||||
* Created Time: 2022-12-23
|
||||
* Author: haptear (haptear@hotmail.com)
|
||||
*/
|
||||
|
||||
namespace hello_algo.chapter_sorting;
|
||||
|
||||
class quickSort {
|
||||
/* Обмен элементов */
|
||||
static void Swap(int[] nums, int i, int j) {
|
||||
(nums[j], nums[i]) = (nums[i], nums[j]);
|
||||
}
|
||||
|
||||
/* Разбиение с опорными указателями */
|
||||
static int Partition(int[] nums, int left, int right) {
|
||||
// Взять nums[left] в качестве опорного элемента
|
||||
int i = left, j = right;
|
||||
while (i < j) {
|
||||
while (i < j && nums[j] >= nums[left])
|
||||
j--; // Идти справа налево в поисках первого элемента меньше опорного
|
||||
while (i < j && nums[i] <= nums[left])
|
||||
i++; // Идти слева направо в поисках первого элемента больше опорного
|
||||
Swap(nums, i, j); // Поменять эти два элемента местами
|
||||
}
|
||||
Swap(nums, i, left); // Переместить опорный элемент на границу двух подмассивов
|
||||
return i; // Вернуть индекс опорного элемента
|
||||
}
|
||||
|
||||
/* Быстрая сортировка */
|
||||
public static void QuickSort(int[] nums, int left, int right) {
|
||||
// Завершить рекурсию, когда длина подмассива равна 1
|
||||
if (left >= right)
|
||||
return;
|
||||
// Разбиение с опорными указателями
|
||||
int pivot = Partition(nums, left, right);
|
||||
// Рекурсивно обработать левый и правый подмассивы
|
||||
QuickSort(nums, left, pivot - 1);
|
||||
QuickSort(nums, pivot + 1, right);
|
||||
}
|
||||
}
|
||||
|
||||
/* Класс быстрой сортировки (оптимизация медианным опорным элементом) */
|
||||
class QuickSortMedian {
|
||||
/* Обмен элементов */
|
||||
static void Swap(int[] nums, int i, int j) {
|
||||
(nums[j], nums[i]) = (nums[i], nums[j]);
|
||||
}
|
||||
|
||||
/* Выбрать медиану из трех кандидатов */
|
||||
static int MedianThree(int[] nums, int left, int mid, int right) {
|
||||
int l = nums[left], m = nums[mid], r = nums[right];
|
||||
if ((l <= m && m <= r) || (r <= m && m <= l))
|
||||
return mid; // m находится между l и r
|
||||
if ((m <= l && l <= r) || (r <= l && l <= m))
|
||||
return left; // l находится между m и r
|
||||
return right;
|
||||
}
|
||||
|
||||
/* Разбиение с опорными указателями (медиана трех) */
|
||||
static int Partition(int[] nums, int left, int right) {
|
||||
// Выбрать медиану из трех кандидатов
|
||||
int med = MedianThree(nums, left, (left + right) / 2, right);
|
||||
// Переместить медиану в крайний левый элемент массива
|
||||
Swap(nums, left, med);
|
||||
// Взять nums[left] в качестве опорного элемента
|
||||
int i = left, j = right;
|
||||
while (i < j) {
|
||||
while (i < j && nums[j] >= nums[left])
|
||||
j--; // Идти справа налево в поисках первого элемента меньше опорного
|
||||
while (i < j && nums[i] <= nums[left])
|
||||
i++; // Идти слева направо в поисках первого элемента больше опорного
|
||||
Swap(nums, i, j); // Поменять эти два элемента местами
|
||||
}
|
||||
Swap(nums, i, left); // Переместить опорный элемент на границу двух подмассивов
|
||||
return i; // Вернуть индекс опорного элемента
|
||||
}
|
||||
|
||||
/* Быстрая сортировка */
|
||||
public static void QuickSort(int[] nums, int left, int right) {
|
||||
// Завершить рекурсию, когда длина подмассива равна 1
|
||||
if (left >= right)
|
||||
return;
|
||||
// Разбиение с опорными указателями
|
||||
int pivot = Partition(nums, left, right);
|
||||
// Рекурсивно обработать левый и правый подмассивы
|
||||
QuickSort(nums, left, pivot - 1);
|
||||
QuickSort(nums, pivot + 1, right);
|
||||
}
|
||||
}
|
||||
|
||||
/* Класс быстрой сортировки (оптимизация глубины рекурсии) */
|
||||
class QuickSortTailCall {
|
||||
/* Обмен элементов */
|
||||
static void Swap(int[] nums, int i, int j) {
|
||||
(nums[j], nums[i]) = (nums[i], nums[j]);
|
||||
}
|
||||
|
||||
/* Разбиение с опорными указателями */
|
||||
static int Partition(int[] nums, int left, int right) {
|
||||
// Взять nums[left] в качестве опорного элемента
|
||||
int i = left, j = right;
|
||||
while (i < j) {
|
||||
while (i < j && nums[j] >= nums[left])
|
||||
j--; // Идти справа налево в поисках первого элемента меньше опорного
|
||||
while (i < j && nums[i] <= nums[left])
|
||||
i++; // Идти слева направо в поисках первого элемента больше опорного
|
||||
Swap(nums, i, j); // Поменять эти два элемента местами
|
||||
}
|
||||
Swap(nums, i, left); // Переместить опорный элемент на границу двух подмассивов
|
||||
return i; // Вернуть индекс опорного элемента
|
||||
}
|
||||
|
||||
/* Быстрая сортировка (оптимизация глубины рекурсии) */
|
||||
public static void QuickSort(int[] nums, int left, int right) {
|
||||
// Завершить, когда длина подмассива равна 1
|
||||
while (left < right) {
|
||||
// Операция разбиения с опорными указателями
|
||||
int pivot = Partition(nums, left, right);
|
||||
// Выполнить быструю сортировку для более короткого из двух подмассивов
|
||||
if (pivot - left < right - pivot) {
|
||||
QuickSort(nums, left, pivot - 1); // Рекурсивно отсортировать левый подмассив
|
||||
left = pivot + 1; // Оставшийся неотсортированный диапазон: [pivot + 1, right]
|
||||
} else {
|
||||
QuickSort(nums, pivot + 1, right); // Рекурсивно отсортировать правый подмассив
|
||||
right = pivot - 1; // Оставшийся неотсортированный диапазон: [left, pivot - 1]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public class quick_sort {
|
||||
[Test]
|
||||
public void Test() {
|
||||
/* Быстрая сортировка */
|
||||
int[] nums = [2, 4, 1, 0, 3, 5];
|
||||
quickSort.QuickSort(nums, 0, nums.Length - 1);
|
||||
Console.WriteLine("После быстрой сортировки nums = " + string.Join(",", nums));
|
||||
|
||||
/* Быстрая сортировка (оптимизация медианным опорным элементом) */
|
||||
int[] nums1 = [2, 4, 1, 0, 3, 5];
|
||||
QuickSortMedian.QuickSort(nums1, 0, nums1.Length - 1);
|
||||
Console.WriteLine("После быстрой сортировки (оптимизация медианным опорным элементом) nums1 = " + string.Join(",", nums1));
|
||||
|
||||
/* Быстрая сортировка (оптимизация глубины рекурсии) */
|
||||
int[] nums2 = [2, 4, 1, 0, 3, 5];
|
||||
QuickSortTailCall.QuickSort(nums2, 0, nums2.Length - 1);
|
||||
Console.WriteLine("После быстрой сортировки (оптимизация глубины рекурсии) nums2 = " + string.Join(",", nums2));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,69 @@
|
||||
/**
|
||||
* File: radix_sort.cs
|
||||
* Created Time: 2023-04-13
|
||||
* Author: hpstory (hpstory1024@163.com)
|
||||
*/
|
||||
|
||||
namespace hello_algo.chapter_sorting;
|
||||
|
||||
public class radix_sort {
|
||||
/* Получить k-й разряд элемента num, где exp = 10^(k-1) */
|
||||
int Digit(int num, int exp) {
|
||||
// Передача exp вместо k позволяет избежать повторного дорогостоящего вычисления степени
|
||||
return (num / exp) % 10;
|
||||
}
|
||||
|
||||
/* Сортировка подсчетом (сортировка по k-му разряду nums) */
|
||||
void CountingSortDigit(int[] nums, int exp) {
|
||||
// Разряды десятичной системы лежат в диапазоне 0~9, поэтому нужен массив корзин длины 10
|
||||
int[] counter = new int[10];
|
||||
int n = nums.Length;
|
||||
// Подсчитать число появлений каждой цифры от 0 до 9
|
||||
for (int i = 0; i < n; i++) {
|
||||
int d = Digit(nums[i], exp); // Получить k-й разряд nums[i], обозначив его как d
|
||||
counter[d]++; // Подсчитать число появлений цифры d
|
||||
}
|
||||
// Вычислить префиксные суммы и преобразовать «число появлений» в «индекс массива»
|
||||
for (int i = 1; i < 10; i++) {
|
||||
counter[i] += counter[i - 1];
|
||||
}
|
||||
// Выполняя обратный проход, заполнить res элементами по статистике в корзинах
|
||||
int[] res = new int[n];
|
||||
for (int i = n - 1; i >= 0; i--) {
|
||||
int d = Digit(nums[i], exp);
|
||||
int j = counter[d] - 1; // Получить индекс j цифры d в массиве
|
||||
res[j] = nums[i]; // Поместить текущий элемент по индексу j
|
||||
counter[d]--; // Уменьшить количество d на 1
|
||||
}
|
||||
// Перезаписать исходный массив nums результатом
|
||||
for (int i = 0; i < n; i++) {
|
||||
nums[i] = res[i];
|
||||
}
|
||||
}
|
||||
|
||||
/* Поразрядная сортировка */
|
||||
void RadixSort(int[] nums) {
|
||||
// Получить максимальный элемент массива, чтобы определить максимальное число разрядов
|
||||
int m = int.MinValue;
|
||||
foreach (int num in nums) {
|
||||
if (num > m) m = num;
|
||||
}
|
||||
// Проходить разряды от младшего к старшему
|
||||
for (int exp = 1; exp <= m; exp *= 10) {
|
||||
// Выполнить сортировку подсчетом по k-му разряду элементов массива
|
||||
// k = 1 -> exp = 1
|
||||
// k = 2 -> exp = 10
|
||||
// то есть exp = 10^(k-1)
|
||||
CountingSortDigit(nums, exp);
|
||||
}
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Test() {
|
||||
// Поразрядная сортировка
|
||||
int[] nums = [ 10546151, 35663510, 42865989, 34862445, 81883077,
|
||||
88906420, 72429244, 30524779, 82060337, 63832996 ];
|
||||
RadixSort(nums);
|
||||
Console.WriteLine("После поразрядной сортировки nums = " + string.Join(" ", nums));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,32 @@
|
||||
/**
|
||||
* File: selection_sort.cs
|
||||
* Created Time: 2023-06-01
|
||||
* Author: hpstory (hpstory1024@163.com)
|
||||
*/
|
||||
|
||||
namespace hello_algo.chapter_sorting;
|
||||
|
||||
public class selection_sort {
|
||||
/* Сортировка выбором */
|
||||
void SelectionSort(int[] nums) {
|
||||
int n = nums.Length;
|
||||
// Внешний цикл: неотсортированный диапазон [i, n-1]
|
||||
for (int i = 0; i < n - 1; i++) {
|
||||
// Внутренний цикл: найти минимальный элемент в неотсортированном диапазоне
|
||||
int k = i;
|
||||
for (int j = i + 1; j < n; j++) {
|
||||
if (nums[j] < nums[k])
|
||||
k = j; // Записать индекс минимального элемента
|
||||
}
|
||||
// Поменять этот минимальный элемент местами с первым элементом неотсортированного диапазона
|
||||
(nums[k], nums[i]) = (nums[i], nums[k]);
|
||||
}
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Test() {
|
||||
int[] nums = [4, 1, 3, 1, 5, 2];
|
||||
SelectionSort(nums);
|
||||
Console.WriteLine("После сортировки выбором nums = " + string.Join(" ", nums));
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user