xinyin025/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-07-06 04:34:20 +00:00
Code Issues Packages Projects Releases Wiki Activity

build

Browse Source
This commit is contained in:
krahets
2026-03-29 02:26:00 +08:00
parent 63276d36d9
commit 37523d4ceb
118 changed files with 74250 additions and 21 deletions
Download Patch File Download Diff File Expand all files Collapse all files
ru/docs/chapter_sorting/bubble_sort.md
+634
View File
@@ -0,0 +1,634 @@
---
comments: true
---
# 11.3   Сортировка пузырьком
<u>Сортировка пузырьком (bubble sort)</u> сортирует массив за счет непрерывного сравнения и обмена соседних элементов. Этот процесс напоминает всплытие пузырьков снизу вверх, откуда и произошло название алгоритма.
Как показано на рисунке 11-4, процесс "всплытия" можно смоделировать через операцию обмена элементов: начиная от левого края массива и двигаясь вправо, мы последовательно сравниваем соседние элементы и, если "левый элемент > правый элемент", меняем их местами. После завершения прохода максимальный элемент будет перемещен в самый правый конец массива.
=== "<1>"
![Моделирование пузырька через обмен элементов](bubble_sort.assets/bubble_operation_step1.png){ class="animation-figure" }
=== "<2>"
![bubble_operation_step2](bubble_sort.assets/bubble_operation_step2.png){ class="animation-figure" }
=== "<3>"
![bubble_operation_step3](bubble_sort.assets/bubble_operation_step3.png){ class="animation-figure" }
=== "<4>"
![bubble_operation_step4](bubble_sort.assets/bubble_operation_step4.png){ class="animation-figure" }
=== "<5>"
![bubble_operation_step5](bubble_sort.assets/bubble_operation_step5.png){ class="animation-figure" }
=== "<6>"
![bubble_operation_step6](bubble_sort.assets/bubble_operation_step6.png){ class="animation-figure" }
=== "<7>"
![bubble_operation_step7](bubble_sort.assets/bubble_operation_step7.png){ class="animation-figure" }
<p align="center"> Рисунок 11-4 &nbsp; Моделирование пузырька через обмен элементов </p>
## 11.3.1 &nbsp; Алгоритм
Пусть длина массива равна $n$ ; тогда шаги сортировки пузырьком показаны на рисунке 11-5.
1. Сначала выполнить один проход "всплытия" по $n$ элементам, **переместив максимальный элемент массива на правильную позицию**.
2. Затем выполнить "всплытие" по оставшимся $n - 1$ элементам, **переместив второй по величине элемент на правильную позицию**.
3. Продолжать по аналогии; после $n - 1$ раундов "всплытия" **первые $n - 1$ по величине элементы окажутся на правильных позициях**.
4. Оставшийся единственный элемент обязательно является минимальным, сортировать его уже не нужно, поэтому сортировка завершена.
![Процесс сортировки пузырьком](bubble_sort.assets/bubble_sort_overview.png){ class="animation-figure" }
<p align="center"> Рисунок 11-5 &nbsp; Процесс сортировки пузырьком </p>
Пример кода:
=== "Python"
```python title="bubble_sort.py"
def bubble_sort(nums: list[int]):
"""Пузырьковая сортировка"""
n = len(nums)
# Внешний цикл: неотсортированный диапазон [0, i]
for i in range(n - 1, 0, -1):
# Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
for j in range(i):
if nums[j] > nums[j + 1]:
# Поменять местами nums[j] и nums[j + 1]
nums[j], nums[j + 1] = nums[j + 1], nums[j]
```
=== "C++"
```cpp title="bubble_sort.cpp"
/* Пузырьковая сортировка */
void bubbleSort(vector<int> &nums) {
// Внешний цикл: неотсортированный диапазон [0, i]
for (int i = nums.size() - 1; i > 0; i--) {
// Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
for (int j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
// Поменять местами nums[j] и nums[j + 1]
// Здесь используется функция std::swap()
swap(nums[j], nums[j + 1]);
}
}
}
}
```
=== "Java"
```java title="bubble_sort.java"
/* Пузырьковая сортировка */
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]
int tmp = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = tmp;
}
}
}
}
```
=== "C#"
```csharp title="bubble_sort.cs"
/* Пузырьковая сортировка */
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]);
}
}
}
}
```
=== "Go"
```go title="bubble_sort.go"
/* Пузырьковая сортировка */
func bubbleSort(nums []int) {
// Внешний цикл: неотсортированный диапазон [0, i]
for i := len(nums) - 1; i > 0; i-- {
// Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
for j := 0; j < i; j++ {
if nums[j] > nums[j+1] {
// Поменять местами nums[j] и nums[j + 1]
nums[j], nums[j+1] = nums[j+1], nums[j]
}
}
}
}
```
=== "Swift"
```swift title="bubble_sort.swift"
/* Пузырьковая сортировка */
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)
}
}
}
}
```
=== "JS"
```javascript title="bubble_sort.js"
/* Пузырьковая сортировка */
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;
}
}
}
}
```
=== "TS"
```typescript title="bubble_sort.ts"
/* Пузырьковая сортировка */
function bubbleSort(nums: number[]): void {
// Внешний цикл: неотсортированный диапазон [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;
}
}
}
}
```
=== "Dart"
```dart title="bubble_sort.dart"
/* Пузырьковая сортировка */
void bubbleSort(List<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]
int tmp = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = tmp;
}
}
}
}
```
=== "Rust"
```rust title="bubble_sort.rs"
/* Пузырьковая сортировка */
fn bubble_sort(nums: &mut [i32]) {
// Внешний цикл: неотсортированный диапазон [0, i]
for i in (1..nums.len()).rev() {
// Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
for j in 0..i {
if nums[j] > nums[j + 1] {
// Поменять местами nums[j] и nums[j + 1]
nums.swap(j, j + 1);
}
}
}
}
```
=== "C"
```c title="bubble_sort.c"
/* Пузырьковая сортировка */
void bubbleSort(int nums[], int size) {
// Внешний цикл: неотсортированный диапазон [0, i]
for (int i = size - 1; i > 0; i--) {
// Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
for (int j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
int temp = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = temp;
}
}
}
}
```
=== "Kotlin"
```kotlin title="bubble_sort.kt"
/* Пузырьковая сортировка */
fun bubbleSort(nums: IntArray) {
// Внешний цикл: неотсортированный диапазон [0, i]
for (i in nums.size - 1 downTo 1) {
// Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
for (j in 0..<i) {
if (nums[j] > nums[j + 1]) {
// Поменять местами nums[j] и nums[j + 1]
val temp = nums[j]
nums[j] = nums[j + 1]
nums[j + 1] = temp
}
}
}
}
```
=== "Ruby"
```ruby title="bubble_sort.rb"
=begin
File: bubble_sort.rb
Created Time: 2024-05-02
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
=end
# ## Пузырьковая сортировка ###
def bubble_sort(nums)
n = nums.length
# Внешний цикл: неотсортированный диапазон [0, i]
for i in (n - 1).downto(1)
# Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
for j in 0...i
if nums[j] > nums[j + 1]
# Поменять местами nums[j] и nums[j + 1]
nums[j], nums[j + 1] = nums[j + 1], nums[j]
end
end
end
end
```
??? pythontutor "Визуализация кода"
<div style="height: 477px; width: 100%;"><iframe class="pythontutor-iframe" src="https://pythontutor.com/iframe-embed.html#code=def%20bubble_sort%28nums%3A%20list%5Bint%5D%29%3A%0A%20%20%20%20%22%22%22%D0%9F%D1%83%D0%B7%D1%8B%D1%80%D1%8C%D0%BA%D0%BE%D0%B2%D0%B0%D1%8F%20%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0%22%22%22%0A%20%20%20%20n%20%3D%20len%28nums%29%0A%20%20%20%20%23%20%D0%92%D0%BD%D0%B5%D1%88%D0%BD%D0%B8%D0%B9%20%D1%86%D0%B8%D0%BA%D0%BB%3A%20%D0%BD%D0%B5%D0%BE%D1%82%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D1%8B%D0%B9%20%D0%B4%D0%B8%D0%B0%D0%BF%D0%B0%D0%B7%D0%BE%D0%BD%20%5B0%2C%20i%5D%0A%20%20%20%20for%20i%20in%20range%28n%20-%201%2C%200%2C%20-1%29%3A%0A%20%20%20%20%20%20%20%20%23%20%D0%92%D0%BD%D1%83%D1%82%D1%80%D0%B5%D0%BD%D0%BD%D0%B8%D0%B9%20%D1%86%D0%B8%D0%BA%D0%BB%3A%20%D0%BF%D0%B5%D1%80%D0%B5%D0%BC%D0%B5%D1%81%D1%82%D0%B8%D1%82%D1%8C%20%D0%BC%D0%B0%D0%BA%D1%81%D0%B8%D0%BC%D0%B0%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%BD%D0%B5%D0%BE%D1%82%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%B3%D0%BE%20%D0%B4%D0%B8%D0%B0%D0%BF%D0%B0%D0%B7%D0%BE%D0%BD%D0%B0%20%5B0%2C%20i%5D%20%D0%B2%20%D0%B5%D0%B3%D0%BE%20%D0%BF%D1%80%D0%B0%D0%B2%D1%8B%D0%B9%20%D0%BA%D0%BE%D0%BD%D0%B5%D1%86%0A%20%20%20%20%20%20%20%20for%20j%20in%20range%28i%29%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20if%20nums%5Bj%5D%20%3E%20nums%5Bj%20%2B%201%5D%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%20%D0%9F%D0%BE%D0%BC%D0%B5%D0%BD%D1%8F%D1%82%D1%8C%20%D0%BC%D0%B5%D1%81%D1%82%D0%B0%D0%BC%D0%B8%20nums%5Bj%5D%20%D0%B8%20nums%5Bj%20%2B%201%5D%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20nums%5Bj%5D%2C%20nums%5Bj%20%2B%201%5D%20%3D%20nums%5Bj%20%2B%201%5D%2C%20nums%5Bj%5D%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20nums%20%3D%20%5B4%2C%201%2C%203%2C%201%2C%205%2C%202%5D%0A%20%20%20%20bubble_sort%28nums%29%0A%20%20%20%20print%28%22%D0%9F%D0%BE%D1%81%D0%BB%D0%B5%20%D0%BF%D1%83%D0%B7%D1%8B%D1%80%D1%8C%D0%BA%D0%BE%D0%B2%D0%BE%D0%B9%20%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B8%20nums%20%3D%22%2C%20nums%29&codeDivHeight=472&codeDivWidth=350&cumulative=false&curInstr=4&heapPrimitives=nevernest&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false"> </iframe></div>
<div style="margin-top: 5px;"><a href="https://pythontutor.com/iframe-embed.html#code=def%20bubble_sort%28nums%3A%20list%5Bint%5D%29%3A%0A%20%20%20%20%22%22%22%D0%9F%D1%83%D0%B7%D1%8B%D1%80%D1%8C%D0%BA%D0%BE%D0%B2%D0%B0%D1%8F%20%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0%22%22%22%0A%20%20%20%20n%20%3D%20len%28nums%29%0A%20%20%20%20%23%20%D0%92%D0%BD%D0%B5%D1%88%D0%BD%D0%B8%D0%B9%20%D1%86%D0%B8%D0%BA%D0%BB%3A%20%D0%BD%D0%B5%D0%BE%D1%82%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D1%8B%D0%B9%20%D0%B4%D0%B8%D0%B0%D0%BF%D0%B0%D0%B7%D0%BE%D0%BD%20%5B0%2C%20i%5D%0A%20%20%20%20for%20i%20in%20range%28n%20-%201%2C%200%2C%20-1%29%3A%0A%20%20%20%20%20%20%20%20%23%20%D0%92%D0%BD%D1%83%D1%82%D1%80%D0%B5%D0%BD%D0%BD%D0%B8%D0%B9%20%D1%86%D0%B8%D0%BA%D0%BB%3A%20%D0%BF%D0%B5%D1%80%D0%B5%D0%BC%D0%B5%D1%81%D1%82%D0%B8%D1%82%D1%8C%20%D0%BC%D0%B0%D0%BA%D1%81%D0%B8%D0%BC%D0%B0%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%BD%D0%B5%D0%BE%D1%82%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%B3%D0%BE%20%D0%B4%D0%B8%D0%B0%D0%BF%D0%B0%D0%B7%D0%BE%D0%BD%D0%B0%20%5B0%2C%20i%5D%20%D0%B2%20%D0%B5%D0%B3%D0%BE%20%D0%BF%D1%80%D0%B0%D0%B2%D1%8B%D0%B9%20%D0%BA%D0%BE%D0%BD%D0%B5%D1%86%0A%20%20%20%20%20%20%20%20for%20j%20in%20range%28i%29%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20if%20nums%5Bj%5D%20%3E%20nums%5Bj%20%2B%201%5D%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%20%D0%9F%D0%BE%D0%BC%D0%B5%D0%BD%D1%8F%D1%82%D1%8C%20%D0%BC%D0%B5%D1%81%D1%82%D0%B0%D0%BC%D0%B8%20nums%5Bj%5D%20%D0%B8%20nums%5Bj%20%2B%201%5D%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20nums%5Bj%5D%2C%20nums%5Bj%20%2B%201%5D%20%3D%20nums%5Bj%20%2B%201%5D%2C%20nums%5Bj%5D%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20nums%20%3D%20%5B4%2C%201%2C%203%2C%201%2C%205%2C%202%5D%0A%20%20%20%20bubble_sort%28nums%29%0A%20%20%20%20print%28%22%D0%9F%D0%BE%D1%81%D0%BB%D0%B5%20%D0%BF%D1%83%D0%B7%D1%8B%D1%80%D1%8C%D0%BA%D0%BE%D0%B2%D0%BE%D0%B9%20%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B8%20nums%20%3D%22%2C%20nums%29&codeDivHeight=800&codeDivWidth=600&cumulative=false&curInstr=4&heapPrimitives=nevernest&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false" target="_blank" rel="noopener noreferrer">Во весь экран ></a></div>
## 11.3.2 &nbsp; Оптимизация эффективности
Мы замечаем, что если в каком-либо раунде "всплытия" не произошло ни одного обмена, значит, массив уже отсортирован и можно сразу вернуть результат. Поэтому можно добавить флаг `flag` для отслеживания этой ситуации и немедленного выхода.
После такой оптимизации худшая и средняя временные сложности сортировки пузырьком по-прежнему равны $O(n^2)$ ; однако если входной массив уже полностью упорядочен, достигается лучшая временная сложность $O(n)$ .
=== "Python"
```python title="bubble_sort.py"
def bubble_sort_with_flag(nums: list[int]):
"""Пузырьковая сортировка (оптимизация флагом)"""
n = len(nums)
# Внешний цикл: неотсортированный диапазон [0, i]
for i in range(n - 1, 0, -1):
flag = False # Инициализировать флаг
# Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
for j in range(i):
if nums[j] > nums[j + 1]:
# Поменять местами nums[j] и nums[j + 1]
nums[j], nums[j + 1] = nums[j + 1], nums[j]
flag = True # Записать обмен элементов
if not flag:
break # На этой итерации «всплытия» не было ни одного обмена, сразу выйти
```
=== "C++"
```cpp title="bubble_sort.cpp"
/* Пузырьковая сортировка (оптимизация флагом) */
void bubbleSortWithFlag(vector<int> &nums) {
// Внешний цикл: неотсортированный диапазон [0, i]
for (int i = nums.size() - 1; i > 0; i--) {
bool flag = false; // Инициализировать флаг
// Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
for (int j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
// Поменять местами nums[j] и nums[j + 1]
// Здесь используется функция std::swap()
swap(nums[j], nums[j + 1]);
flag = true; // Записать обмен элементов
}
}
if (!flag)
break; // На этой итерации «всплытия» не было ни одного обмена, сразу выйти
}
}
```
=== "Java"
```java title="bubble_sort.java"
/* Пузырьковая сортировка (оптимизация флагом) */
void bubbleSortWithFlag(int[] nums) {
// Внешний цикл: неотсортированный диапазон [0, i]
for (int i = nums.length - 1; i > 0; i--) {
boolean flag = false; // Инициализировать флаг
// Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
for (int j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
// Поменять местами nums[j] и nums[j + 1]
int tmp = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = tmp;
flag = true; // Записать обмен элементов
}
}
if (!flag)
break; // На этой итерации «всплытия» не было ни одного обмена, сразу выйти
}
}
```
=== "C#"
```csharp title="bubble_sort.cs"
/* Пузырьковая сортировка (оптимизация флагом) */
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; // На этой итерации «всплытия» не было ни одного обмена, сразу выйти
}
}
```
=== "Go"
```go title="bubble_sort.go"
/* Пузырьковая сортировка (оптимизация флагом) */
func bubbleSortWithFlag(nums []int) {
// Внешний цикл: неотсортированный диапазон [0, i]
for i := len(nums) - 1; i > 0; i-- {
flag := false // Инициализировать флаг
// Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
for j := 0; j < i; j++ {
if nums[j] > nums[j+1] {
// Поменять местами nums[j] и nums[j + 1]
nums[j], nums[j+1] = nums[j+1], nums[j]
flag = true // Записать обмен элементов
}
}
if flag == false { // На этой итерации «всплытия» не было ни одного обмена, сразу выйти
break
}
}
}
```
=== "Swift"
```swift title="bubble_sort.swift"
/* Пузырьковая сортировка (оптимизация флагом) */
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
}
}
}
```
=== "JS"
```javascript title="bubble_sort.js"
/* Пузырьковая сортировка (оптимизация флагом) */
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; // На этой итерации «всплытия» не было ни одного обмена, сразу выйти
}
}
```
=== "TS"
```typescript title="bubble_sort.ts"
/* Пузырьковая сортировка (оптимизация флагом) */
function bubbleSortWithFlag(nums: number[]): void {
// Внешний цикл: неотсортированный диапазон [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; // На этой итерации «всплытия» не было ни одного обмена, сразу выйти
}
}
```
=== "Dart"
```dart title="bubble_sort.dart"
/* Пузырьковая сортировка (оптимизация флагом) */
void bubbleSortWithFlag(List<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]
int tmp = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = tmp;
flag = true; // Записать обмен элементов
}
}
if (!flag) break; // На этой итерации «всплытия» не было ни одного обмена, сразу выйти
}
}
```
=== "Rust"
```rust title="bubble_sort.rs"
/* Пузырьковая сортировка (оптимизация флагом) */
fn bubble_sort_with_flag(nums: &mut [i32]) {
// Внешний цикл: неотсортированный диапазон [0, i]
for i in (1..nums.len()).rev() {
let mut flag = false; // Инициализировать флаг
// Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
for j in 0..i {
if nums[j] > nums[j + 1] {
// Поменять местами nums[j] и nums[j + 1]
nums.swap(j, j + 1);
flag = true; // Записать обмен элементов
}
}
if !flag {
break; // На этой итерации «всплытия» не было ни одного обмена, сразу выйти
};
}
}
```
=== "C"
```c title="bubble_sort.c"
/* Пузырьковая сортировка (оптимизация флагом) */
void bubbleSortWithFlag(int nums[], int size) {
// Внешний цикл: неотсортированный диапазон [0, i]
for (int i = size - 1; i > 0; i--) {
bool flag = false;
// Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
for (int j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
int temp = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = temp;
flag = true;
}
}
if (!flag)
break;
}
}
```
=== "Kotlin"
```kotlin title="bubble_sort.kt"
/* Пузырьковая сортировка (оптимизация флагом) */
fun bubbleSortWithFlag(nums: IntArray) {
// Внешний цикл: неотсортированный диапазон [0, i]
for (i in nums.size - 1 downTo 1) {
var flag = false // Инициализировать флаг
// Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
for (j in 0..<i) {
if (nums[j] > nums[j + 1]) {
// Поменять местами nums[j] и nums[j + 1]
val temp = nums[j]
nums[j] = nums[j + 1]
nums[j + 1] = temp
flag = true // Записать обмен элементов
}
}
if (!flag) break // На этой итерации «всплытия» не было ни одного обмена, сразу выйти
}
}
```
=== "Ruby"
```ruby title="bubble_sort.rb"
=begin
File: bubble_sort.rb
Created Time: 2024-05-02
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
=end
# ## Пузырьковая сортировка ###
def bubble_sort(nums)
n = nums.length
# Внешний цикл: неотсортированный диапазон [0, i]
for i in (n - 1).downto(1)
# Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
for j in 0...i
if nums[j] > nums[j + 1]
# Поменять местами nums[j] и nums[j + 1]
nums[j], nums[j + 1] = nums[j + 1], nums[j]
end
end
end
end
# ## Пузырьковая сортировка (оптимизация флагом) ###
def bubble_sort_with_flag(nums)
n = nums.length
# Внешний цикл: неотсортированный диапазон [0, i]
for i in (n - 1).downto(1)
flag = false # Инициализировать флаг
# Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
for j in 0...i
if nums[j] > nums[j + 1]
# Поменять местами nums[j] и nums[j + 1]
nums[j], nums[j + 1] = nums[j + 1], nums[j]
flag = true # Записать обмен элементов
end
end
break unless flag # На этой итерации «всплытия» не было ни одного обмена, сразу выйти
end
end
```
??? pythontutor "Визуализация кода"
<div style="height: 549px; width: 100%;"><iframe class="pythontutor-iframe" src="https://pythontutor.com/iframe-embed.html#code=def%20bubble_sort_with_flag%28nums%3A%20list%5Bint%5D%29%3A%0A%20%20%20%20%22%22%22%D0%9F%D1%83%D0%B7%D1%8B%D1%80%D1%8C%D0%BA%D0%BE%D0%B2%D0%B0%D1%8F%20%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0%20%28%D0%BE%D0%BF%D1%82%D0%B8%D0%BC%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F%20%D1%84%D0%BB%D0%B0%D0%B3%D0%BE%D0%BC%29%22%22%22%0A%20%20%20%20n%20%3D%20len%28nums%29%0A%20%20%20%20%23%20%D0%92%D0%BD%D0%B5%D1%88%D0%BD%D0%B8%D0%B9%20%D1%86%D0%B8%D0%BA%D0%BB%3A%20%D0%BD%D0%B5%D0%BE%D1%82%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D1%8B%D0%B9%20%D0%B4%D0%B8%D0%B0%D0%BF%D0%B0%D0%B7%D0%BE%D0%BD%20%5B0%2C%20i%5D%0A%20%20%20%20for%20i%20in%20range%28n%20-%201%2C%200%2C%20-1%29%3A%0A%20%20%20%20%20%20%20%20flag%20%3D%20False%20%20%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D1%84%D0%BB%D0%B0%D0%B3%0A%20%20%20%20%20%20%20%20%23%20%D0%92%D0%BD%D1%83%D1%82%D1%80%D0%B5%D0%BD%D0%BD%D0%B8%D0%B9%20%D1%86%D0%B8%D0%BA%D0%BB%3A%20%D0%BF%D0%B5%D1%80%D0%B5%D0%BC%D0%B5%D1%81%D1%82%D0%B8%D1%82%D1%8C%20%D0%BC%D0%B0%D0%BA%D1%81%D0%B8%D0%BC%D0%B0%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%BD%D0%B5%D0%BE%D1%82%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%B3%D0%BE%20%D0%B4%D0%B8%D0%B0%D0%BF%D0%B0%D0%B7%D0%BE%D0%BD%D0%B0%20%5B0%2C%20i%5D%20%D0%B2%20%D0%B5%D0%B3%D0%BE%20%D0%BF%D1%80%D0%B0%D0%B2%D1%8B%D0%B9%20%D0%BA%D0%BE%D0%BD%D0%B5%D1%86%0A%20%20%20%20%20%20%20%20for%20j%20in%20range%28i%29%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20if%20nums%5Bj%5D%20%3E%20nums%5Bj%20%2B%201%5D%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%20%D0%9F%D0%BE%D0%BC%D0%B5%D0%BD%D1%8F%D1%82%D1%8C%20%D0%BC%D0%B5%D1%81%D1%82%D0%B0%D0%BC%D0%B8%20nums%5Bj%5D%20%D0%B8%20nums%5Bj%20%2B%201%5D%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20nums%5Bj%5D%2C%20nums%5Bj%20%2B%201%5D%20%3D%20nums%5Bj%20%2B%201%5D%2C%20nums%5Bj%5D%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20flag%20%3D%20True%20%20%23%20%D0%97%D0%B0%D0%BF%D0%B8%D1%81%D0%B0%D1%82%D1%8C%20%D0%BE%D0%B1%D0%BC%D0%B5%D0%BD%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D0%BE%D0%B2%0A%20%20%20%20%20%20%20%20if%20not%20flag%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20break%20%20%23%20%D0%9D%D0%B0%20%D1%8D%D1%82%D0%BE%D0%B9%20%D0%B8%D1%82%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8%20%C2%AB%D0%B2%D1%81%D0%BF%D0%BB%D1%8B%D1%82%D0%B8%D1%8F%C2%BB%20%D0%BD%D0%B5%20%D0%B1%D1%8B%D0%BB%D0%BE%20%D0%BD%D0%B8%20%D0%BE%D0%B4%D0%BD%D0%BE%D0%B3%D0%BE%20%D0%BE%D0%B1%D0%BC%D0%B5%D0%BD%D0%B0%2C%20%D1%81%D1%80%D0%B0%D0%B7%D1%83%20%D0%B2%D1%8B%D0%B9%D1%82%D0%B8%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20nums%20%3D%20%5B4%2C%201%2C%203%2C%201%2C%205%2C%202%5D%0A%20%20%20%20bubble_sort_with_flag%28nums%29%0A%20%20%20%20print%28%22%D0%9F%D0%BE%D1%81%D0%BB%D0%B5%20%D0%BF%D1%83%D0%B7%D1%8B%D1%80%D1%8C%D0%BA%D0%BE%D0%B2%D0%BE%D0%B9%20%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B8%20nums%20%3D%22%2C%20nums%29&codeDivHeight=472&codeDivWidth=350&cumulative=false&curInstr=4&heapPrimitives=nevernest&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false"> </iframe></div>
<div style="margin-top: 5px;"><a href="https://pythontutor.com/iframe-embed.html#code=def%20bubble_sort_with_flag%28nums%3A%20list%5Bint%5D%29%3A%0A%20%20%20%20%22%22%22%D0%9F%D1%83%D0%B7%D1%8B%D1%80%D1%8C%D0%BA%D0%BE%D0%B2%D0%B0%D1%8F%20%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0%20%28%D0%BE%D0%BF%D1%82%D0%B8%D0%BC%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F%20%D1%84%D0%BB%D0%B0%D0%B3%D0%BE%D0%BC%29%22%22%22%0A%20%20%20%20n%20%3D%20len%28nums%29%0A%20%20%20%20%23%20%D0%92%D0%BD%D0%B5%D1%88%D0%BD%D0%B8%D0%B9%20%D1%86%D0%B8%D0%BA%D0%BB%3A%20%D0%BD%D0%B5%D0%BE%D1%82%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D1%8B%D0%B9%20%D0%B4%D0%B8%D0%B0%D0%BF%D0%B0%D0%B7%D0%BE%D0%BD%20%5B0%2C%20i%5D%0A%20%20%20%20for%20i%20in%20range%28n%20-%201%2C%200%2C%20-1%29%3A%0A%20%20%20%20%20%20%20%20flag%20%3D%20False%20%20%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D1%84%D0%BB%D0%B0%D0%B3%0A%20%20%20%20%20%20%20%20%23%20%D0%92%D0%BD%D1%83%D1%82%D1%80%D0%B5%D0%BD%D0%BD%D0%B8%D0%B9%20%D1%86%D0%B8%D0%BA%D0%BB%3A%20%D0%BF%D0%B5%D1%80%D0%B5%D0%BC%D0%B5%D1%81%D1%82%D0%B8%D1%82%D1%8C%20%D0%BC%D0%B0%D0%BA%D1%81%D0%B8%D0%BC%D0%B0%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%BD%D0%B5%D0%BE%D1%82%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%B3%D0%BE%20%D0%B4%D0%B8%D0%B0%D0%BF%D0%B0%D0%B7%D0%BE%D0%BD%D0%B0%20%5B0%2C%20i%5D%20%D0%B2%20%D0%B5%D0%B3%D0%BE%20%D0%BF%D1%80%D0%B0%D0%B2%D1%8B%D0%B9%20%D0%BA%D0%BE%D0%BD%D0%B5%D1%86%0A%20%20%20%20%20%20%20%20for%20j%20in%20range%28i%29%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20if%20nums%5Bj%5D%20%3E%20nums%5Bj%20%2B%201%5D%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%20%D0%9F%D0%BE%D0%BC%D0%B5%D0%BD%D1%8F%D1%82%D1%8C%20%D0%BC%D0%B5%D1%81%D1%82%D0%B0%D0%BC%D0%B8%20nums%5Bj%5D%20%D0%B8%20nums%5Bj%20%2B%201%5D%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20nums%5Bj%5D%2C%20nums%5Bj%20%2B%201%5D%20%3D%20nums%5Bj%20%2B%201%5D%2C%20nums%5Bj%5D%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20flag%20%3D%20True%20%20%23%20%D0%97%D0%B0%D0%BF%D0%B8%D1%81%D0%B0%D1%82%D1%8C%20%D0%BE%D0%B1%D0%BC%D0%B5%D0%BD%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D0%BE%D0%B2%0A%20%20%20%20%20%20%20%20if%20not%20flag%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20break%20%20%23%20%D0%9D%D0%B0%20%D1%8D%D1%82%D0%BE%D0%B9%20%D0%B8%D1%82%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8%20%C2%AB%D0%B2%D1%81%D0%BF%D0%BB%D1%8B%D1%82%D0%B8%D1%8F%C2%BB%20%D0%BD%D0%B5%20%D0%B1%D1%8B%D0%BB%D0%BE%20%D0%BD%D0%B8%20%D0%BE%D0%B4%D0%BD%D0%BE%D0%B3%D0%BE%20%D0%BE%D0%B1%D0%BC%D0%B5%D0%BD%D0%B0%2C%20%D1%81%D1%80%D0%B0%D0%B7%D1%83%20%D0%B2%D1%8B%D0%B9%D1%82%D0%B8%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20nums%20%3D%20%5B4%2C%201%2C%203%2C%201%2C%205%2C%202%5D%0A%20%20%20%20bubble_sort_with_flag%28nums%29%0A%20%20%20%20print%28%22%D0%9F%D0%BE%D1%81%D0%BB%D0%B5%20%D0%BF%D1%83%D0%B7%D1%8B%D1%80%D1%8C%D0%BA%D0%BE%D0%B2%D0%BE%D0%B9%20%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B8%20nums%20%3D%22%2C%20nums%29&codeDivHeight=800&codeDivWidth=600&cumulative=false&curInstr=4&heapPrimitives=nevernest&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false" target="_blank" rel="noopener noreferrer">Во весь экран ></a></div>
## 11.3.3 &nbsp; Характеристики алгоритма
- **Временная сложность равна $O(n^2)$, алгоритм адаптивен**: длины диапазонов, проходящих "всплытие" в разных раундах, последовательно равны $n - 1$, $n - 2$, $\dots$, $2$, $1$ , а их сумма равна $(n - 1) n / 2$ . После добавления оптимизации с `flag` лучшая временная сложность может достигать $O(n)$ .
- **Пространственная сложность равна $O(1)$, сортировка выполняется на месте**: указатели $i$ и $j$ используют константный объем дополнительной памяти.
- **Стабильная сортировка**: поскольку при "всплытии" равные элементы не обмениваются местами.
ru/docs/chapter_sorting/bucket_sort.md
+477
View File
@@ -0,0 +1,477 @@
---
comments: true
---
# 11.8 &nbsp; Блочная сортировка
Рассмотренные выше алгоритмы сортировки относятся к "сортировкам на основе сравнений": они упорядочивают данные, сравнивая элементы друг с другом. Временная сложность таких алгоритмов не может быть лучше $O(n \log n)$ . Далее мы рассмотрим несколько "сортировок без сравнений", чья временная сложность может достигать линейного порядка.
<u>Блочная сортировка (bucket sort)</u> является типичным применением стратегии "разделяй и властвуй". Она задает несколько упорядоченных по диапазонам блоков, каждый блок соответствует некоторому диапазону значений; затем данные равномерно распределяются по блокам, внутри каждого блока выполняется сортировка, а в конце результаты блоков объединяются по порядку.
## 11.8.1 &nbsp; Алгоритм
Рассмотрим массив длины $n$, элементы которого являются числами с плавающей запятой из диапазона $[0, 1)$ . Процесс блочной сортировки показан на рисунке 11-13.
1. Инициализировать $k$ блоков и распределить $n$ элементов по этим $k$ блокам.
2. Отсортировать каждый блок по отдельности (здесь используется встроенная функция сортировки языка программирования).
3. Объединить результаты в порядке следования блоков от меньшего к большему.
![Процесс блочной сортировки](bucket_sort.assets/bucket_sort_overview.png){ class="animation-figure" }
<p align="center"> Рисунок 11-13 &nbsp; Процесс блочной сортировки </p>
Код приведен ниже:
=== "Python"
```python title="bucket_sort.py"
def bucket_sort(nums: list[float]):
"""Сортировка корзинами"""
# Инициализировать k = n/2 корзин, предполагая распределение 2 элементов в каждую корзину
k = len(nums) // 2
buckets = [[] for _ in range(k)]
# 1. Распределить элементы массива по корзинам
for num in nums:
# Входные данные лежат в диапазоне [0, 1); использовать num * k для отображения в диапазон индексов [0, k-1]
i = int(num * k)
# Добавить num в корзину i
buckets[i].append(num)
# 2. Выполнить сортировку внутри каждой корзины
for bucket in buckets:
# Использовать встроенную функцию сортировки; ее также можно заменить другим алгоритмом сортировки
bucket.sort()
# 3. Обойти корзины и объединить результаты
i = 0
for bucket in buckets:
for num in bucket:
nums[i] = num
i += 1
```
=== "C++"
```cpp title="bucket_sort.cpp"
/* Сортировка корзинами */
void bucketSort(vector<float> &nums) {
// Инициализировать k = n/2 корзин, предполагая распределение 2 элементов в каждую корзину
int k = nums.size() / 2;
vector<vector<float>> buckets(k);
// 1. Распределить элементы массива по корзинам
for (float num : nums) {
// Входные данные лежат в диапазоне [0, 1); использовать num * k для отображения в диапазон индексов [0, k-1]
int i = num * k;
// Добавить num в корзину bucket_idx
buckets[i].push_back(num);
}
// 2. Выполнить сортировку внутри каждой корзины
for (vector<float> &bucket : buckets) {
// Использовать встроенную функцию сортировки; ее также можно заменить другим алгоритмом сортировки
sort(bucket.begin(), bucket.end());
}
// 3. Обойти корзины и объединить результаты
int i = 0;
for (vector<float> &bucket : buckets) {
for (float num : bucket) {
nums[i++] = num;
}
}
}
```
=== "Java"
```java title="bucket_sort.java"
/* Сортировка корзинами */
void bucketSort(float[] nums) {
// Инициализировать k = n/2 корзин, предполагая распределение 2 элементов в каждую корзину
int k = nums.length / 2;
List<List<Float>> buckets = new ArrayList<>();
for (int i = 0; i < k; i++) {
buckets.add(new ArrayList<>());
}
// 1. Распределить элементы массива по корзинам
for (float num : nums) {
// Входные данные лежат в диапазоне [0, 1); использовать num * k для отображения в диапазон индексов [0, k-1]
int i = (int) (num * k);
// Добавить num в корзину i
buckets.get(i).add(num);
}
// 2. Выполнить сортировку внутри каждой корзины
for (List<Float> bucket : buckets) {
// Использовать встроенную функцию сортировки; ее также можно заменить другим алгоритмом сортировки
Collections.sort(bucket);
}
// 3. Обойти корзины и объединить результаты
int i = 0;
for (List<Float> bucket : buckets) {
for (float num : bucket) {
nums[i++] = num;
}
}
}
```
=== "C#"
```csharp title="bucket_sort.cs"
/* Сортировка корзинами */
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;
}
}
}
```
=== "Go"
```go title="bucket_sort.go"
/* Сортировка корзинами */
func bucketSort(nums []float64) {
// Инициализировать k = n/2 корзин, предполагая распределение 2 элементов в каждую корзину
k := len(nums) / 2
buckets := make([][]float64, k)
for i := 0; i < k; i++ {
buckets[i] = make([]float64, 0)
}
// 1. Распределить элементы массива по корзинам
for _, num := range nums {
// Входные данные лежат в диапазоне [0, 1); использовать num * k для отображения в диапазон индексов [0, k-1]
i := int(num * float64(k))
// Добавить num в корзину i
buckets[i] = append(buckets[i], num)
}
// 2. Выполнить сортировку внутри каждой корзины
for i := 0; i < k; i++ {
// Использовать встроенную функцию сортировки среза; ее также можно заменить другим алгоритмом сортировки
sort.Float64s(buckets[i])
}
// 3. Обойти корзины и объединить результаты
i := 0
for _, bucket := range buckets {
for _, num := range bucket {
nums[i] = num
i++
}
}
}
```
=== "Swift"
```swift title="bucket_sort.swift"
/* Сортировка корзинами */
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
}
}
}
```
=== "JS"
```javascript title="bucket_sort.js"
/* Сортировка корзинами */
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;
}
}
}
```
=== "TS"
```typescript title="bucket_sort.ts"
/* Сортировка корзинами */
function bucketSort(nums: number[]): void {
// Инициализировать k = n/2 корзин, предполагая распределение 2 элементов в каждую корзину
const k = nums.length / 2;
const buckets: number[][] = [];
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;
}
}
}
```
=== "Dart"
```dart title="bucket_sort.dart"
/* Сортировка корзинами */
void bucketSort(List<double> nums) {
// Инициализировать k = n/2 корзин, предполагая распределение 2 элементов в каждую корзину
int k = nums.length ~/ 2;
List<List<double>> buckets = List.generate(k, (index) => []);
// 1. Распределить элементы массива по корзинам
for (double _num in nums) {
// Входные данные находятся в диапазоне [0, 1), используем _num * k для отображения в диапазон индексов [0, k-1]
int i = (_num * k).toInt();
// Добавить _num в корзину bucket_idx
buckets[i].add(_num);
}
// 2. Выполнить сортировку внутри каждой корзины
for (List<double> bucket in buckets) {
bucket.sort();
}
// 3. Обойти корзины и объединить результаты
int i = 0;
for (List<double> bucket in buckets) {
for (double _num in bucket) {
nums[i++] = _num;
}
}
}
```
=== "Rust"
```rust title="bucket_sort.rs"
/* Сортировка корзинами */
fn bucket_sort(nums: &mut [f64]) {
// Инициализировать k = n/2 корзин, предполагая распределение 2 элементов в каждую корзину
let k = nums.len() / 2;
let mut buckets = vec![vec![]; k];
// 1. Распределить элементы массива по корзинам
for &num in nums.iter() {
// Входные данные лежат в диапазоне [0, 1); использовать num * k для отображения в диапазон индексов [0, k-1]
let i = (num * k as f64) as usize;
// Добавить num в корзину i
buckets[i].push(num);
}
// 2. Выполнить сортировку внутри каждой корзины
for bucket in &mut buckets {
// Использовать встроенную функцию сортировки; ее также можно заменить другим алгоритмом сортировки
bucket.sort_by(|a, b| a.partial_cmp(b).unwrap());
}
// 3. Обойти корзины и объединить результаты
let mut i = 0;
for bucket in buckets.iter() {
for &num in bucket.iter() {
nums[i] = num;
i += 1;
}
}
}
```
=== "C"
```c title="bucket_sort.c"
/* Сортировка корзинами */
void bucketSort(float nums[], int n) {
int k = n / 2; // Инициализировать k = n/2 корзин
int *sizes = malloc(k * sizeof(int)); // Записать размер каждой корзины
float **buckets = malloc(k * sizeof(float *)); // Массив динамических массивов (корзины)
// Предварительно выделить достаточно места для каждой корзины
for (int i = 0; i < k; ++i) {
buckets[i] = (float *)malloc(n * sizeof(float));
sizes[i] = 0;
}
// 1. Распределить элементы массива по корзинам
for (int i = 0; i < n; ++i) {
int idx = (int)(nums[i] * k);
buckets[idx][sizes[idx]++] = nums[i];
}
// 2. Выполнить сортировку внутри каждой корзины
for (int i = 0; i < k; ++i) {
qsort(buckets[i], sizes[i], sizeof(float), compare);
}
// 3. Объединить отсортированные корзины
int idx = 0;
for (int i = 0; i < k; ++i) {
for (int j = 0; j < sizes[i]; ++j) {
nums[idx++] = buckets[i][j];
}
// Освободить память
free(buckets[i]);
}
}
```
=== "Kotlin"
```kotlin title="bucket_sort.kt"
/* Сортировка корзинами */
fun bucketSort(nums: FloatArray) {
// Инициализировать k = n/2 корзин, предполагая распределение 2 элементов в каждую корзину
val k = nums.size / 2
val buckets = mutableListOf<MutableList<Float>>()
for (i in 0..<k) {
buckets.add(mutableListOf())
}
// 1. Распределить элементы массива по корзинам
for (num in nums) {
// Входные данные лежат в диапазоне [0, 1); использовать num * k для отображения в диапазон индексов [0, k-1]
val i = (num * k).toInt()
// Добавить num в корзину i
buckets[i].add(num)
}
// 2. Выполнить сортировку внутри каждой корзины
for (bucket in buckets) {
// Использовать встроенную функцию сортировки; ее также можно заменить другим алгоритмом сортировки
bucket.sort()
}
// 3. Обойти корзины и объединить результаты
var i = 0
for (bucket in buckets) {
for (num in bucket) {
nums[i++] = num
}
}
}
```
=== "Ruby"
```ruby title="bucket_sort.rb"
=begin
File: bucket_sort.rb
Created Time: 2024-04-17
Author: Martin Xu (martin.xus@gmail.com)
=end
# ## Сортировка корзинами ###
def bucket_sort(nums)
# Инициализировать k = n/2 корзин, предполагая распределение 2 элементов в каждую корзину
k = nums.length / 2
buckets = Array.new(k) { [] }
# 1. Распределить элементы массива по корзинам
nums.each do |num|
# Входные данные лежат в диапазоне [0, 1); использовать num * k для отображения в диапазон индексов [0, k-1]
i = (num * k).to_i
# Добавить num в корзину i
buckets[i] << num
end
# 2. Выполнить сортировку внутри каждой корзины
buckets.each do |bucket|
# Использовать встроенную функцию сортировки; ее также можно заменить другим алгоритмом сортировки
bucket.sort!
end
# 3. Обойти корзины и объединить результаты
i = 0
buckets.each do |bucket|
bucket.each do |num|
nums[i] = num
i += 1
end
end
end
```
??? pythontutor "Визуализация кода"
<div style="height: 549px; width: 100%;"><iframe class="pythontutor-iframe" src="https://pythontutor.com/iframe-embed.html#code=def%20bucket_sort%28nums%3A%20list%5Bfloat%5D%29%3A%0A%20%20%20%20%22%22%22%D0%A1%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0%20%D0%BA%D0%BE%D1%80%D0%B7%D0%B8%D0%BD%D0%B0%D0%BC%D0%B8%22%22%22%0A%20%20%20%20%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20k%20%3D%20n%2F2%20%D0%BA%D0%BE%D1%80%D0%B7%D0%B8%D0%BD%2C%20%D0%BF%D1%80%D0%B5%D0%B4%D0%BF%D0%BE%D0%BB%D0%B0%D0%B3%D0%B0%D1%8F%20%D1%80%D0%B0%D1%81%D0%BF%D1%80%D0%B5%D0%B4%D0%B5%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5%202%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D0%BE%D0%B2%20%D0%B2%20%D0%BA%D0%B0%D0%B6%D0%B4%D1%83%D1%8E%20%D0%BA%D0%BE%D1%80%D0%B7%D0%B8%D0%BD%D1%83%0A%20%20%20%20k%20%3D%20len%28nums%29%20%2F%2F%202%0A%20%20%20%20buckets%20%3D%20%5B%5B%5D%20for%20_%20in%20range%28k%29%5D%0A%20%20%20%20%23%201.%20%D0%A0%D0%B0%D1%81%D0%BF%D1%80%D0%B5%D0%B4%D0%B5%D0%BB%D0%B8%D1%82%D1%8C%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D1%8B%20%D0%BC%D0%B0%D1%81%D1%81%D0%B8%D0%B2%D0%B0%20%D0%BF%D0%BE%20%D0%BA%D0%BE%D1%80%D0%B7%D0%B8%D0%BD%D0%B0%D0%BC%0A%20%20%20%20for%20num%20in%20nums%3A%0A%20%20%20%20%20%20%20%20%23%20%D0%92%D1%85%D0%BE%D0%B4%D0%BD%D1%8B%D0%B5%20%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D0%B5%20%D0%BB%D0%B5%D0%B6%D0%B0%D1%82%20%D0%B2%20%D0%B4%D0%B8%D0%B0%D0%BF%D0%B0%D0%B7%D0%BE%D0%BD%D0%B5%20%5B0%2C%201%29%3B%20%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20num%20%2A%20k%20%D0%B4%D0%BB%D1%8F%20%D0%BE%D1%82%D0%BE%D0%B1%D1%80%D0%B0%D0%B6%D0%B5%D0%BD%D0%B8%D1%8F%20%D0%B2%20%D0%B4%D0%B8%D0%B0%D0%BF%D0%B0%D0%B7%D0%BE%D0%BD%20%D0%B8%D0%BD%D0%B4%D0%B5%D0%BA%D1%81%D0%BE%D0%B2%20%5B0%2C%20k-1%5D%0A%20%20%20%20%20%20%20%20i%20%3D%20int%28num%20%2A%20k%29%0A%20%20%20%20%20%20%20%20%23%20%D0%94%D0%BE%D0%B1%D0%B0%D0%B2%D0%B8%D1%82%D1%8C%20num%20%D0%B2%20%D0%BA%D0%BE%D1%80%D0%B7%D0%B8%D0%BD%D1%83%20i%0A%20%20%20%20%20%20%20%20buckets%5Bi%5D.append%28num%29%0A%20%20%20%20%23%202.%20%D0%92%D1%8B%D0%BF%D0%BE%D0%BB%D0%BD%D0%B8%D1%82%D1%8C%20%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D1%83%20%D0%B2%D0%BD%D1%83%D1%82%D1%80%D0%B8%20%D0%BA%D0%B0%D0%B6%D0%B4%D0%BE%D0%B9%20%D0%BA%D0%BE%D1%80%D0%B7%D0%B8%D0%BD%D1%8B%0A%20%20%20%20for%20bucket%20in%20buckets%3A%0A%20%20%20%20%20%20%20%20%23%20%D0%98%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D0%B2%D1%81%D1%82%D1%80%D0%BE%D0%B5%D0%BD%D0%BD%D1%83%D1%8E%20%D1%84%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D1%8E%20%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B8%3B%20%D0%B5%D0%B5%20%D1%82%D0%B0%D0%BA%D0%B6%D0%B5%20%D0%BC%D0%BE%D0%B6%D0%BD%D0%BE%20%D0%B7%D0%B0%D0%BC%D0%B5%D0%BD%D0%B8%D1%82%D1%8C%20%D0%B4%D1%80%D1%83%D0%B3%D0%B8%D0%BC%20%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC%D0%BE%D0%BC%20%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B8%0A%20%20%20%20%20%20%20%20bucket.sort%28%29%0A%20%20%20%20%23%203.%20%D0%9E%D0%B1%D0%BE%D0%B9%D1%82%D0%B8%20%D0%BA%D0%BE%D1%80%D0%B7%D0%B8%D0%BD%D1%8B%20%D0%B8%20%D0%BE%D0%B1%D1%8A%D0%B5%D0%B4%D0%B8%D0%BD%D0%B8%D1%82%D1%8C%20%D1%80%D0%B5%D0%B7%D1%83%D0%BB%D1%8C%D1%82%D0%B0%D1%82%D1%8B%0A%20%20%20%20i%20%3D%200%0A%20%20%20%20for%20bucket%20in%20buckets%3A%0A%20%20%20%20%20%20%20%20for%20num%20in%20bucket%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20nums%5Bi%5D%20%3D%20num%0A%20%20%20%20%20%20%20%20%20%20%20%20i%20%2B%3D%201%0A%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%D0%9F%D1%83%D1%81%D1%82%D1%8C%20%D0%B2%D1%85%D0%BE%D0%B4%D0%BD%D1%8B%D0%B5%20%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D0%B5%20%E2%80%94%20%D1%87%D0%B8%D1%81%D0%BB%D0%B0%20%D1%81%20%D0%BF%D0%BB%D0%B0%D0%B2%D0%B0%D1%8E%D1%89%D0%B5%D0%B9%20%D1%82%D0%BE%D1%87%D0%BA%D0%BE%D0%B9%20%D0%B8%D0%B7%20%D0%B4%D0%B8%D0%B0%D0%BF%D0%B0%D0%B7%D0%BE%D0%BD%D0%B0%20%5B0%2C%201%29%0A%20%20%20%20nums%20%3D%20%5B0.49%2C%200.96%2C%200.82%2C%200.09%2C%200.57%2C%200.43%2C%200.91%2C%200.75%2C%200.15%2C%200.37%5D%0A%20%20%20%20bucket_sort%28nums%29%0A%20%20%20%20print%28%22%D0%9F%D0%BE%D1%81%D0%BB%D0%B5%20%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B8%20%D0%BA%D0%BE%D1%80%D0%B7%D0%B8%D0%BD%D0%B0%D0%BC%D0%B8%20nums%20%3D%22%2C%20nums%29&codeDivHeight=472&codeDivWidth=350&cumulative=false&curInstr=3&heapPrimitives=nevernest&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false"> </iframe></div>
<div style="margin-top: 5px;"><a href="https://pythontutor.com/iframe-embed.html#code=def%20bucket_sort%28nums%3A%20list%5Bfloat%5D%29%3A%0A%20%20%20%20%22%22%22%D0%A1%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0%20%D0%BA%D0%BE%D1%80%D0%B7%D0%B8%D0%BD%D0%B0%D0%BC%D0%B8%22%22%22%0A%20%20%20%20%23%20%D0%98%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20k%20%3D%20n%2F2%20%D0%BA%D0%BE%D1%80%D0%B7%D0%B8%D0%BD%2C%20%D0%BF%D1%80%D0%B5%D0%B4%D0%BF%D0%BE%D0%BB%D0%B0%D0%B3%D0%B0%D1%8F%20%D1%80%D0%B0%D1%81%D0%BF%D1%80%D0%B5%D0%B4%D0%B5%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5%202%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D0%BE%D0%B2%20%D0%B2%20%D0%BA%D0%B0%D0%B6%D0%B4%D1%83%D1%8E%20%D0%BA%D0%BE%D1%80%D0%B7%D0%B8%D0%BD%D1%83%0A%20%20%20%20k%20%3D%20len%28nums%29%20%2F%2F%202%0A%20%20%20%20buckets%20%3D%20%5B%5B%5D%20for%20_%20in%20range%28k%29%5D%0A%20%20%20%20%23%201.%20%D0%A0%D0%B0%D1%81%D0%BF%D1%80%D0%B5%D0%B4%D0%B5%D0%BB%D0%B8%D1%82%D1%8C%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D1%8B%20%D0%BC%D0%B0%D1%81%D1%81%D0%B8%D0%B2%D0%B0%20%D0%BF%D0%BE%20%D0%BA%D0%BE%D1%80%D0%B7%D0%B8%D0%BD%D0%B0%D0%BC%0A%20%20%20%20for%20num%20in%20nums%3A%0A%20%20%20%20%20%20%20%20%23%20%D0%92%D1%85%D0%BE%D0%B4%D0%BD%D1%8B%D0%B5%20%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D0%B5%20%D0%BB%D0%B5%D0%B6%D0%B0%D1%82%20%D0%B2%20%D0%B4%D0%B8%D0%B0%D0%BF%D0%B0%D0%B7%D0%BE%D0%BD%D0%B5%20%5B0%2C%201%29%3B%20%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20num%20%2A%20k%20%D0%B4%D0%BB%D1%8F%20%D0%BE%D1%82%D0%BE%D0%B1%D1%80%D0%B0%D0%B6%D0%B5%D0%BD%D0%B8%D1%8F%20%D0%B2%20%D0%B4%D0%B8%D0%B0%D0%BF%D0%B0%D0%B7%D0%BE%D0%BD%20%D0%B8%D0%BD%D0%B4%D0%B5%D0%BA%D1%81%D0%BE%D0%B2%20%5B0%2C%20k-1%5D%0A%20%20%20%20%20%20%20%20i%20%3D%20int%28num%20%2A%20k%29%0A%20%20%20%20%20%20%20%20%23%20%D0%94%D0%BE%D0%B1%D0%B0%D0%B2%D0%B8%D1%82%D1%8C%20num%20%D0%B2%20%D0%BA%D0%BE%D1%80%D0%B7%D0%B8%D0%BD%D1%83%20i%0A%20%20%20%20%20%20%20%20buckets%5Bi%5D.append%28num%29%0A%20%20%20%20%23%202.%20%D0%92%D1%8B%D0%BF%D0%BE%D0%BB%D0%BD%D0%B8%D1%82%D1%8C%20%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D1%83%20%D0%B2%D0%BD%D1%83%D1%82%D1%80%D0%B8%20%D0%BA%D0%B0%D0%B6%D0%B4%D0%BE%D0%B9%20%D0%BA%D0%BE%D1%80%D0%B7%D0%B8%D0%BD%D1%8B%0A%20%20%20%20for%20bucket%20in%20buckets%3A%0A%20%20%20%20%20%20%20%20%23%20%D0%98%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D0%B2%D1%81%D1%82%D1%80%D0%BE%D0%B5%D0%BD%D0%BD%D1%83%D1%8E%20%D1%84%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D1%8E%20%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B8%3B%20%D0%B5%D0%B5%20%D1%82%D0%B0%D0%BA%D0%B6%D0%B5%20%D0%BC%D0%BE%D0%B6%D0%BD%D0%BE%20%D0%B7%D0%B0%D0%BC%D0%B5%D0%BD%D0%B8%D1%82%D1%8C%20%D0%B4%D1%80%D1%83%D0%B3%D0%B8%D0%BC%20%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC%D0%BE%D0%BC%20%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B8%0A%20%20%20%20%20%20%20%20bucket.sort%28%29%0A%20%20%20%20%23%203.%20%D0%9E%D0%B1%D0%BE%D0%B9%D1%82%D0%B8%20%D0%BA%D0%BE%D1%80%D0%B7%D0%B8%D0%BD%D1%8B%20%D0%B8%20%D0%BE%D0%B1%D1%8A%D0%B5%D0%B4%D0%B8%D0%BD%D0%B8%D1%82%D1%8C%20%D1%80%D0%B5%D0%B7%D1%83%D0%BB%D1%8C%D1%82%D0%B0%D1%82%D1%8B%0A%20%20%20%20i%20%3D%200%0A%20%20%20%20for%20bucket%20in%20buckets%3A%0A%20%20%20%20%20%20%20%20for%20num%20in%20bucket%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20nums%5Bi%5D%20%3D%20num%0A%20%20%20%20%20%20%20%20%20%20%20%20i%20%2B%3D%201%0A%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%D0%9F%D1%83%D1%81%D1%82%D1%8C%20%D0%B2%D1%85%D0%BE%D0%B4%D0%BD%D1%8B%D0%B5%20%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D0%B5%20%E2%80%94%20%D1%87%D0%B8%D1%81%D0%BB%D0%B0%20%D1%81%20%D0%BF%D0%BB%D0%B0%D0%B2%D0%B0%D1%8E%D1%89%D0%B5%D0%B9%20%D1%82%D0%BE%D1%87%D0%BA%D0%BE%D0%B9%20%D0%B8%D0%B7%20%D0%B4%D0%B8%D0%B0%D0%BF%D0%B0%D0%B7%D0%BE%D0%BD%D0%B0%20%5B0%2C%201%29%0A%20%20%20%20nums%20%3D%20%5B0.49%2C%200.96%2C%200.82%2C%200.09%2C%200.57%2C%200.43%2C%200.91%2C%200.75%2C%200.15%2C%200.37%5D%0A%20%20%20%20bucket_sort%28nums%29%0A%20%20%20%20print%28%22%D0%9F%D0%BE%D1%81%D0%BB%D0%B5%20%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B8%20%D0%BA%D0%BE%D1%80%D0%B7%D0%B8%D0%BD%D0%B0%D0%BC%D0%B8%20nums%20%3D%22%2C%20nums%29&codeDivHeight=800&codeDivWidth=600&cumulative=false&curInstr=3&heapPrimitives=nevernest&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false" target="_blank" rel="noopener noreferrer">Во весь экран ></a></div>
## 11.8.2 &nbsp; Характеристики алгоритма
Блочная сортировка подходит для обработки очень больших объемов данных. Например, если вход содержит 1 миллион элементов и из-за ограничений памяти система не может загрузить их все сразу, можно разбить данные на 1000 блоков, отсортировать каждый блок отдельно, а затем объединить результаты.
- **Временная сложность равна $O(n + k)$** : если элементы распределены по блокам равномерно, то в каждом блоке будет $\frac{n}{k}$ элементов. Если сортировка одного блока требует $O(\frac{n}{k} \log\frac{n}{k})$ времени, то сортировка всех блоков потребует $O(n \log\frac{n}{k})$ времени. **Когда число блоков $k$ достаточно велико, временная сложность приближается к $O(n)$** . На объединение результатов требуется $O(n + k)$ времени, потому что нужно пройти по всем блокам и элементам. В худшем случае все данные попадут в один блок, и если сортировка этого блока использует $O(n^2)$ времени, общая сложность также станет $O(n^2)$ .
- **Пространственная сложность равна $O(n + k)$, сортировка не выполняется на месте**: требуются дополнительные блоки в количестве $k$ и место для всех $n$ элементов внутри них.
- Является ли блочная сортировка стабильной, зависит от того, стабилен ли алгоритм сортировки внутри каждого блока.
## 11.8.3 &nbsp; Как добиться равномерного распределения
Теоретически временная сложность блочной сортировки может достигать $O(n)$ ; **ключ к этому - как можно более равномерно распределить элементы по блокам**. На практике данные часто распределены неравномерно. Например, если нужно распределить все товары на Taobao по 10 блокам цен, количество товаров дешевле 100 юаней может быть очень большим, а товаров дороже 1000 юаней - очень маленьким. Если просто разбить диапазон цен на 10 равных частей, число товаров в каждом блоке будет сильно различаться.
Чтобы добиться более равномерного распределения, можно сначала задать грубую линию раздела и приблизительно распределить данные по 3 блокам. **После этого блоки с большим числом товаров можно снова делить на 3 блока и продолжать процесс до тех пор, пока число элементов в каждом блоке не станет примерно одинаковым**.
Как показано на рисунке 11-14, по сути этот метод строит рекурсивное дерево, цель которого - сделать значения в листьях как можно более равномерными. Конечно, совсем не обязательно каждый раз делить данные именно на 3 блока; конкретную схему разбиения можно выбирать в зависимости от свойств данных.
![Рекурсивное разбиение по блокам](bucket_sort.assets/scatter_in_buckets_recursively.png){ class="animation-figure" }
<p align="center"> Рисунок 11-14 &nbsp; Рекурсивное разбиение по блокам </p>
Если нам заранее известна вероятностная модель распределения цен товаров, **то границы каждого блока можно задавать в соответствии с этим распределением**. Важно отметить, что фактическое распределение данных не обязательно специально измерять - его можно приблизить некоторой вероятностной моделью исходя из свойств данных.
Как показано на рисунке 11-15, если предположить, что цены товаров подчиняются нормальному распределению, то можно разумно задать интервалы цен и тем самым распределить товары по блокам достаточно равномерно.
![Разбиение блоков по вероятностному распределению](bucket_sort.assets/scatter_in_buckets_distribution.png){ class="animation-figure" }
<p align="center"> Рисунок 11-15 &nbsp; Разбиение блоков по вероятностному распределению </p>
ru/docs/chapter_sorting/counting_sort.md
+929
View File
File diff suppressed because one or more lines are too long
ru/docs/chapter_sorting/heap_sort.md
+654
View File
File diff suppressed because one or more lines are too long
ru/docs/chapter_sorting/index.md
+28
View File
@@ -0,0 +1,28 @@
---
comments: true
icon: material/sort-ascending
---
# Глава 11. &nbsp; Сортировка
![Сортировка](../assets/covers/chapter_sorting.jpg){ class="cover-image" }
!!! abstract
Сортировка упорядочивает хаотичные данные и позволяет быстрее находить закономерности.
За кажущейся простотой скрывается целая группа алгоритмов с разными достоинствами и ограничениями.
## Содержание главы
- [11.1 &nbsp; Алгоритмы сортировки](sorting_algorithm.md)
- [11.2 &nbsp; Сортировка выбором](selection_sort.md)
- [11.3 &nbsp; Пузырьковая сортировка](bubble_sort.md)
- [11.4 &nbsp; Сортировка вставкой](insertion_sort.md)
- [11.5 &nbsp; Быстрая сортировка](quick_sort.md)
- [11.6 &nbsp; Сортировка слиянием](merge_sort.md)
- [11.7 &nbsp; Пирамидальная сортировка](heap_sort.md)
- [11.8 &nbsp; Блочная сортировка](bucket_sort.md)
- [11.9 &nbsp; Сортировка подсчетом](counting_sort.md)
- [11.10 &nbsp; Поразрядная сортировка](radix_sort.md)
- [11.11 &nbsp; Резюме](summary.md)
ru/docs/chapter_sorting/insertion_sort.md
+302
View File
@@ -0,0 +1,302 @@
---
comments: true
---
# 11.4 &nbsp; Сортировка вставками
<u>Сортировка вставками (insertion sort)</u> - это простой алгоритм сортировки, принцип которого очень похож на ручное упорядочивание колоды карт.
Точнее говоря, в неотсортированном диапазоне выбирается опорный элемент, после чего он поочередно сравнивается с элементами слева в уже отсортированном диапазоне и вставляется в правильную позицию.
На рисунке 11-6 показан процесс вставки элемента в массив. Пусть опорный элемент обозначен как `base` ; нам нужно сдвинуть все элементы от целевого индекса до `base` на одну позицию вправо, а затем присвоить `base` значение в целевом индексе.
![Одна операция вставки](insertion_sort.assets/insertion_operation.png){ class="animation-figure" }
<p align="center"> Рисунок 11-6 &nbsp; Одна операция вставки </p>
## 11.4.1 &nbsp; Алгоритм
Общий процесс сортировки вставками показан на рисунке 11-7.
1. В начальном состоянии отсортирован только первый элемент массива.
2. Выбрать второй элемент массива как `base` ; после вставки в правильную позицию **первые 2 элемента массива окажутся отсортированными**.
3. Выбрать третий элемент как `base` ; после вставки в правильную позицию **первые 3 элемента массива окажутся отсортированными**.
4. Продолжать по аналогии; в последнем раунде в качестве `base` берется последний элемент, и после его вставки **все элементы массива будут отсортированы**.
![Процесс сортировки вставками](insertion_sort.assets/insertion_sort_overview.png){ class="animation-figure" }
<p align="center"> Рисунок 11-7 &nbsp; Процесс сортировки вставками </p>
Пример кода:
=== "Python"
```python title="insertion_sort.py"
def insertion_sort(nums: list[int]):
"""Сортировка вставками"""
# Внешний цикл: отсортированный диапазон [0, i-1]
for i in range(1, len(nums)):
base = nums[i]
j = i - 1
# Внутренний цикл: вставить base в правильную позицию отсортированного диапазона [0, i-1]
while j >= 0 and nums[j] > base:
nums[j + 1] = nums[j] # Сдвинуть nums[j] на одну позицию вправо
j -= 1
nums[j + 1] = base # Поместить base в правильную позицию
```
=== "C++"
```cpp title="insertion_sort.cpp"
/* Сортировка вставками */
void insertionSort(vector<int> &nums) {
// Внешний цикл: отсортированный диапазон [0, i-1]
for (int i = 1; i < nums.size(); i++) {
int base = nums[i], j = i - 1;
// Внутренний цикл: вставить base в правильную позицию отсортированного диапазона [0, i-1]
while (j >= 0 && nums[j] > base) {
nums[j + 1] = nums[j]; // Сдвинуть nums[j] на одну позицию вправо
j--;
}
nums[j + 1] = base; // Поместить base в правильную позицию
}
}
```
=== "Java"
```java title="insertion_sort.java"
/* Сортировка вставками */
void insertionSort(int[] nums) {
// Внешний цикл: отсортированный диапазон [0, i-1]
for (int i = 1; i < nums.length; i++) {
int base = nums[i], j = i - 1;
// Внутренний цикл: вставить base в правильную позицию отсортированного диапазона [0, i-1]
while (j >= 0 && nums[j] > base) {
nums[j + 1] = nums[j]; // Сдвинуть nums[j] на одну позицию вправо
j--;
}
nums[j + 1] = base; // Поместить base в правильную позицию
}
}
```
=== "C#"
```csharp title="insertion_sort.cs"
/* Сортировка вставками */
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 в правильную позицию
}
}
```
=== "Go"
```go title="insertion_sort.go"
/* Сортировка вставками */
func insertionSort(nums []int) {
// Внешний цикл: отсортированный диапазон [0, i-1]
for i := 1; i < len(nums); i++ {
base := nums[i]
j := i - 1
// Внутренний цикл: вставить base в правильную позицию отсортированного диапазона [0, i-1]
for j >= 0 && nums[j] > base {
nums[j+1] = nums[j] // Сдвинуть nums[j] на одну позицию вправо
j--
}
nums[j+1] = base // Поместить base в правильную позицию
}
}
```
=== "Swift"
```swift title="insertion_sort.swift"
/* Сортировка вставками */
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 в правильную позицию
}
}
```
=== "JS"
```javascript title="insertion_sort.js"
/* Сортировка вставками */
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 в правильную позицию
}
}
```
=== "TS"
```typescript title="insertion_sort.ts"
/* Сортировка вставками */
function insertionSort(nums: number[]): void {
// Внешний цикл: отсортированный диапазон [0, i-1]
for (let i = 1; i < nums.length; i++) {
const base = nums[i];
let 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 в правильную позицию
}
}
```
=== "Dart"
```dart title="insertion_sort.dart"
/* Сортировка вставками */
void insertionSort(List<int> nums) {
// Внешний цикл: отсортированный диапазон [0, i-1]
for (int i = 1; i < nums.length; i++) {
int base = nums[i], j = i - 1;
// Внутренний цикл: вставить base в правильную позицию отсортированного диапазона [0, i-1]
while (j >= 0 && nums[j] > base) {
nums[j + 1] = nums[j]; // Сдвинуть nums[j] на одну позицию вправо
j--;
}
nums[j + 1] = base; // Поместить base в правильную позицию
}
}
```
=== "Rust"
```rust title="insertion_sort.rs"
/* Сортировка вставками */
fn insertion_sort(nums: &mut [i32]) {
// Внешний цикл: отсортированный диапазон [0, i-1]
for i in 1..nums.len() {
let (base, mut j) = (nums[i], (i - 1) as i32);
// Внутренний цикл: вставить base в правильную позицию отсортированного диапазона [0, i-1]
while j >= 0 && nums[j as usize] > base {
nums[(j + 1) as usize] = nums[j as usize]; // Сдвинуть nums[j] на одну позицию вправо
j -= 1;
}
nums[(j + 1) as usize] = base; // Поместить base в правильную позицию
}
}
```
=== "C"
```c title="insertion_sort.c"
/* Сортировка вставками */
void insertionSort(int nums[], int size) {
// Внешний цикл: отсортированный диапазон [0, i-1]
for (int i = 1; i < size; i++) {
int base = nums[i], j = i - 1;
// Внутренний цикл: вставить base в правильную позицию отсортированного диапазона [0, i-1]
while (j >= 0 && nums[j] > base) {
// Сдвинуть nums[j] на одну позицию вправо
nums[j + 1] = nums[j];
j--;
}
// Поместить base в правильную позицию
nums[j + 1] = base;
}
}
```
=== "Kotlin"
```kotlin title="insertion_sort.kt"
/* Сортировка вставками */
fun insertionSort(nums: IntArray) {
// Внешний цикл: отсортированные элементы равны 1, 2, ..., n
for (i in nums.indices) {
val 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--
}
nums[j + 1] = base // Поместить base в правильную позицию
}
}
```
=== "Ruby"
```ruby title="insertion_sort.rb"
=begin
File: insertion_sort.rb
Created Time: 2024-04-02
Author: Cy (3739004@gmail.com), Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
=end
# ## Сортировка вставками ###
def insertion_sort(nums)
n = nums.length
# Внешний цикл: отсортированный диапазон [0, i-1]
for i in 1...n
base = nums[i]
j = i - 1
# Внутренний цикл: вставить base в правильную позицию отсортированного диапазона [0, i-1]
while j >= 0 && nums[j] > base
nums[j + 1] = nums[j] # Сдвинуть nums[j] на одну позицию вправо
j -= 1
end
nums[j + 1] = base # Поместить base в правильную позицию
end
end
```
??? pythontutor "Визуализация кода"
<div style="height: 513px; width: 100%;"><iframe class="pythontutor-iframe" src="https://pythontutor.com/iframe-embed.html#code=def%20insertion_sort%28nums%3A%20list%5Bint%5D%29%3A%0A%20%20%20%20%22%22%22%D0%A1%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0%20%D0%B2%D1%81%D1%82%D0%B0%D0%B2%D0%BA%D0%B0%D0%BC%D0%B8%22%22%22%0A%20%20%20%20%23%20%D0%92%D0%BD%D0%B5%D1%88%D0%BD%D0%B8%D0%B9%20%D1%86%D0%B8%D0%BA%D0%BB%3A%20%D0%BE%D1%82%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D1%8B%D0%B9%20%D0%B4%D0%B8%D0%B0%D0%BF%D0%B0%D0%B7%D0%BE%D0%BD%20%5B0%2C%20i-1%5D%0A%20%20%20%20for%20i%20in%20range%281%2C%20len%28nums%29%29%3A%0A%20%20%20%20%20%20%20%20base%20%3D%20nums%5Bi%5D%0A%20%20%20%20%20%20%20%20j%20%3D%20i%20-%201%0A%20%20%20%20%20%20%20%20%23%20%D0%92%D0%BD%D1%83%D1%82%D1%80%D0%B5%D0%BD%D0%BD%D0%B8%D0%B9%20%D1%86%D0%B8%D0%BA%D0%BB%3A%20%D0%B2%D1%81%D1%82%D0%B0%D0%B2%D0%B8%D1%82%D1%8C%20base%20%D0%B2%20%D0%BF%D1%80%D0%B0%D0%B2%D0%B8%D0%BB%D1%8C%D0%BD%D1%83%D1%8E%20%D0%BF%D0%BE%D0%B7%D0%B8%D1%86%D0%B8%D1%8E%20%D0%BE%D1%82%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%B3%D0%BE%20%D0%B4%D0%B8%D0%B0%D0%BF%D0%B0%D0%B7%D0%BE%D0%BD%D0%B0%20%5B0%2C%20i-1%5D%0A%20%20%20%20%20%20%20%20while%20j%20%3E%3D%200%20and%20nums%5Bj%5D%20%3E%20base%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20nums%5Bj%20%2B%201%5D%20%3D%20nums%5Bj%5D%20%20%23%20%D0%A1%D0%B4%D0%B2%D0%B8%D0%BD%D1%83%D1%82%D1%8C%20nums%5Bj%5D%20%D0%BD%D0%B0%20%D0%BE%D0%B4%D0%BD%D1%83%20%D0%BF%D0%BE%D0%B7%D0%B8%D1%86%D0%B8%D1%8E%20%D0%B2%D0%BF%D1%80%D0%B0%D0%B2%D0%BE%0A%20%20%20%20%20%20%20%20%20%20%20%20j%20-%3D%201%0A%20%20%20%20%20%20%20%20nums%5Bj%20%2B%201%5D%20%3D%20base%20%20%23%20%D0%9F%D0%BE%D0%BC%D0%B5%D1%81%D1%82%D0%B8%D1%82%D1%8C%20base%20%D0%B2%20%D0%BF%D1%80%D0%B0%D0%B2%D0%B8%D0%BB%D1%8C%D0%BD%D1%83%D1%8E%20%D0%BF%D0%BE%D0%B7%D0%B8%D1%86%D0%B8%D1%8E%0A%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20nums%20%3D%20%5B4%2C%201%2C%203%2C%201%2C%205%2C%202%5D%0A%20%20%20%20insertion_sort%28nums%29%0A%20%20%20%20print%28%22%D0%9F%D0%BE%D1%81%D0%BB%D0%B5%20%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B8%20%D0%B2%D1%81%D1%82%D0%B0%D0%B2%D0%BA%D0%B0%D0%BC%D0%B8%20nums%20%3D%22%2C%20nums%29&codeDivHeight=472&codeDivWidth=350&cumulative=false&curInstr=4&heapPrimitives=nevernest&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false"> </iframe></div>
<div style="margin-top: 5px;"><a href="https://pythontutor.com/iframe-embed.html#code=def%20insertion_sort%28nums%3A%20list%5Bint%5D%29%3A%0A%20%20%20%20%22%22%22%D0%A1%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0%20%D0%B2%D1%81%D1%82%D0%B0%D0%B2%D0%BA%D0%B0%D0%BC%D0%B8%22%22%22%0A%20%20%20%20%23%20%D0%92%D0%BD%D0%B5%D1%88%D0%BD%D0%B8%D0%B9%20%D1%86%D0%B8%D0%BA%D0%BB%3A%20%D0%BE%D1%82%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D1%8B%D0%B9%20%D0%B4%D0%B8%D0%B0%D0%BF%D0%B0%D0%B7%D0%BE%D0%BD%20%5B0%2C%20i-1%5D%0A%20%20%20%20for%20i%20in%20range%281%2C%20len%28nums%29%29%3A%0A%20%20%20%20%20%20%20%20base%20%3D%20nums%5Bi%5D%0A%20%20%20%20%20%20%20%20j%20%3D%20i%20-%201%0A%20%20%20%20%20%20%20%20%23%20%D0%92%D0%BD%D1%83%D1%82%D1%80%D0%B5%D0%BD%D0%BD%D0%B8%D0%B9%20%D1%86%D0%B8%D0%BA%D0%BB%3A%20%D0%B2%D1%81%D1%82%D0%B0%D0%B2%D0%B8%D1%82%D1%8C%20base%20%D0%B2%20%D0%BF%D1%80%D0%B0%D0%B2%D0%B8%D0%BB%D1%8C%D0%BD%D1%83%D1%8E%20%D0%BF%D0%BE%D0%B7%D0%B8%D1%86%D0%B8%D1%8E%20%D0%BE%D1%82%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%B3%D0%BE%20%D0%B4%D0%B8%D0%B0%D0%BF%D0%B0%D0%B7%D0%BE%D0%BD%D0%B0%20%5B0%2C%20i-1%5D%0A%20%20%20%20%20%20%20%20while%20j%20%3E%3D%200%20and%20nums%5Bj%5D%20%3E%20base%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20nums%5Bj%20%2B%201%5D%20%3D%20nums%5Bj%5D%20%20%23%20%D0%A1%D0%B4%D0%B2%D0%B8%D0%BD%D1%83%D1%82%D1%8C%20nums%5Bj%5D%20%D0%BD%D0%B0%20%D0%BE%D0%B4%D0%BD%D1%83%20%D0%BF%D0%BE%D0%B7%D0%B8%D1%86%D0%B8%D1%8E%20%D0%B2%D0%BF%D1%80%D0%B0%D0%B2%D0%BE%0A%20%20%20%20%20%20%20%20%20%20%20%20j%20-%3D%201%0A%20%20%20%20%20%20%20%20nums%5Bj%20%2B%201%5D%20%3D%20base%20%20%23%20%D0%9F%D0%BE%D0%BC%D0%B5%D1%81%D1%82%D0%B8%D1%82%D1%8C%20base%20%D0%B2%20%D0%BF%D1%80%D0%B0%D0%B2%D0%B8%D0%BB%D1%8C%D0%BD%D1%83%D1%8E%20%D0%BF%D0%BE%D0%B7%D0%B8%D1%86%D0%B8%D1%8E%0A%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20nums%20%3D%20%5B4%2C%201%2C%203%2C%201%2C%205%2C%202%5D%0A%20%20%20%20insertion_sort%28nums%29%0A%20%20%20%20print%28%22%D0%9F%D0%BE%D1%81%D0%BB%D0%B5%20%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B8%20%D0%B2%D1%81%D1%82%D0%B0%D0%B2%D0%BA%D0%B0%D0%BC%D0%B8%20nums%20%3D%22%2C%20nums%29&codeDivHeight=800&codeDivWidth=600&cumulative=false&curInstr=4&heapPrimitives=nevernest&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false" target="_blank" rel="noopener noreferrer">Во весь экран ></a></div>
## 11.4.2 &nbsp; Характеристики алгоритма
- **Временная сложность равна $O(n^2)$, алгоритм адаптивен**: в худшем случае каждой операции вставки требуется соответственно $n - 1$, $n-2$, $\dots$, $2$, $1$ итераций, а их сумма равна $(n - 1) n / 2$ , поэтому временная сложность равна $O(n^2)$ . Если входные данные уже упорядочены, операция вставки завершается раньше. Когда входной массив полностью отсортирован, сортировка вставками достигает лучшей временной сложности $O(n)$ .
- **Пространственная сложность равна $O(1)$, сортировка выполняется на месте**: указатели $i$ и $j$ используют константный объем дополнительной памяти.
- **Стабильная сортировка**: в процессе вставки элементы помещаются справа от равных им элементов, поэтому их относительный порядок не меняется.
## 11.4.3 &nbsp; Преимущества сортировки вставками
Временная сложность сортировки вставками равна $O(n^2)$ , а у быстрой сортировки, которую мы скоро изучим, временная сложность равна $O(n \log n)$ . Несмотря на более высокую асимптотическую сложность, **на малых объемах данных сортировка вставками обычно работает быстрее**.
Этот вывод похож на сравнение линейного и двоичного поиска. Алгоритмы уровня $O(n \log n)$ , такие как быстрая сортировка, относятся к алгоритмам на основе стратегии "разделяй и властвуй" и обычно включают больше элементарных вычислений. Когда объем данных мал, значения $n^2$ и $n \log n$ близки друг к другу, поэтому асимптотика не доминирует, а решающим становится число элементарных операций в каждом раунде.
На практике встроенные функции сортировки во многих языках программирования (например, в Java) используют сортировку вставками. Общая идея такова: для длинных массивов применять алгоритмы сортировки на основе стратегии "разделяй и властвуй", например быструю сортировку; для коротких массивов сразу использовать сортировку вставками.
Хотя сортировка пузырьком, выбором и вставками имеют одинаковую временную сложность $O(n^2)$ , в реальных задачах **сортировка вставками используется заметно чаще, чем сортировка пузырьком и сортировка выбором**. Основные причины таковы.
- Сортировка пузырьком основана на обмене элементов, для чего нужна временная переменная и суммарно выполняются 3 элементарные операции; сортировка вставками основана на присваивании элементов и требует всего 1 элементарной операции. Поэтому **вычислительные затраты сортировки пузырьком обычно выше, чем у сортировки вставками**.
- Временная сложность сортировки выбором в любом случае равна $O(n^2)$ . **Если входные данные уже частично упорядочены, сортировка вставками обычно эффективнее сортировки выбором**.
- Сортировка выбором нестабильна, поэтому ее нельзя использовать для многоуровневой сортировки.
ru/docs/chapter_sorting/merge_sort.md
+747
View File
@@ -0,0 +1,747 @@
---
comments: true
---
# 11.6 &nbsp; Сортировка слиянием
<u>Сортировка слиянием (merge sort)</u> - это алгоритм сортировки на основе стратегии "разделяй и властвуй", который включает этапы "разделения" и "слияния", показанные на рисунке 11-10.
1. **Этап разделения**: массив рекурсивно разбивается от середины, и задача сортировки длинного массива превращается в задачи сортировки более коротких массивов.
2. **Этап слияния**: когда длина подмассива становится равной 1, разделение завершается и начинается слияние; левые и правые короткие упорядоченные массивы непрерывно объединяются в более длинный упорядоченный массив, пока процесс не завершится.
![Этапы разделения и слияния в сортировке слиянием](merge_sort.assets/merge_sort_overview.png){ class="animation-figure" }
<p align="center"> Рисунок 11-10 &nbsp; Этапы разделения и слияния в сортировке слиянием </p>
## 11.6.1 &nbsp; Алгоритм
Как показано на рисунке 11-11, на этапе "разделения" массив рекурсивно разбивается сверху вниз по середине на два подмассива.
1. Вычислить середину массива `mid` и рекурсивно разделить левый подмассив (интервал `[left, mid]` ) и правый подмассив (интервал `[mid + 1, right]` ).
2. Рекурсивно повторять шаг `1.` , пока длина подмассива не станет равной 1.
Этап "слияния" снизу вверх объединяет левый и правый подмассивы в один упорядоченный массив. Следует заметить, что начиная с подмассивов длины 1, каждый подмассив в фазе слияния уже является упорядоченным.
=== "<1>"
![Шаги сортировки слиянием](merge_sort.assets/merge_sort_step1.png){ class="animation-figure" }
=== "<2>"
![merge_sort_step2](merge_sort.assets/merge_sort_step2.png){ class="animation-figure" }
=== "<3>"
![merge_sort_step3](merge_sort.assets/merge_sort_step3.png){ class="animation-figure" }
=== "<4>"
![merge_sort_step4](merge_sort.assets/merge_sort_step4.png){ class="animation-figure" }
=== "<5>"
![merge_sort_step5](merge_sort.assets/merge_sort_step5.png){ class="animation-figure" }
=== "<6>"
![merge_sort_step6](merge_sort.assets/merge_sort_step6.png){ class="animation-figure" }
=== "<7>"
![merge_sort_step7](merge_sort.assets/merge_sort_step7.png){ class="animation-figure" }
=== "<8>"
![merge_sort_step8](merge_sort.assets/merge_sort_step8.png){ class="animation-figure" }
=== "<9>"
![merge_sort_step9](merge_sort.assets/merge_sort_step9.png){ class="animation-figure" }
=== "<10>"
![merge_sort_step10](merge_sort.assets/merge_sort_step10.png){ class="animation-figure" }
<p align="center"> Рисунок 11-11 &nbsp; Шаги сортировки слиянием </p>
Нетрудно заметить, что порядок рекурсии в сортировке слиянием совпадает с порядком рекурсии при постфиксном обходе бинарного дерева.
- **Постфиксный обход**: сначала рекурсивно обходится левое поддерево, затем правое поддерево, а в конце обрабатывается корневой узел.
- **Сортировка слиянием**: сначала рекурсивно обрабатывается левый подмассив, затем правый подмассив, а в конце выполняется слияние.
Реализация сортировки слиянием показана в коде ниже. Обратите внимание: в `nums` объединяемый интервал равен `[left, right]` , а соответствующий интервал в `tmp` равен `[0, right - left]` .
=== "Python"
```python title="merge_sort.py"
def merge(nums: list[int], left: int, mid: int, right: int):
"""Объединить левый и правый подмассивы"""
# Диапазон левого подмассива: [left, mid], диапазон правого подмассива: [mid+1, right]
# Создать временный массив tmp для хранения результата слияния
tmp = [0] * (right - left + 1)
# Инициализировать начальные индексы левого и правого подмассивов
i, j, k = left, mid + 1, 0
# Пока в левом и правом подмассивах еще есть элементы, сравнивать их и копировать меньший во временный массив
while i <= mid and 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 range(0, len(tmp)):
nums[left + k] = tmp[k]
def merge_sort(nums: list[int], left: int, right: int):
"""Сортировка слиянием"""
# Условие завершения
if left >= right:
return # Завершить рекурсию, когда длина подмассива равна 1
# Этап разбиения
mid = (left + right) // 2 # Вычислить середину
merge_sort(nums, left, mid) # Рекурсивно обработать левый подмассив
merge_sort(nums, mid + 1, right) # Рекурсивно обработать правый подмассив
# Этап слияния
merge(nums, left, mid, right)
```
=== "C++"
```cpp title="merge_sort.cpp"
/* Объединить левый и правый подмассивы */
void merge(vector<int> &nums, int left, int mid, int right) {
// Диапазон левого подмассива: [left, mid], диапазон правого подмассива: [mid+1, right]
// Создать временный массив tmp для хранения результата слияния
vector<int> tmp(right - left + 1);
// Инициализировать начальные индексы левого и правого подмассивов
int i = left, j = mid + 1, k = 0;
// Пока в левом и правом подмассивах еще есть элементы, сравнивать их и копировать меньший во временный массив
while (i <= mid && j <= right) {
if (nums[i] <= nums[j])
tmp[k++] = nums[i++];
else
tmp[k++] = nums[j++];
}
// Скопировать оставшиеся элементы левого и правого подмассивов во временный массив
while (i <= mid) {
tmp[k++] = nums[i++];
}
while (j <= right) {
tmp[k++] = nums[j++];
}
// Скопировать элементы временного массива tmp обратно в соответствующий диапазон исходного массива nums
for (k = 0; k < tmp.size(); k++) {
nums[left + k] = tmp[k];
}
}
/* Сортировка слиянием */
void mergeSort(vector<int> &nums, int left, int right) {
// Условие завершения
if (left >= right)
return; // Завершить рекурсию, когда длина подмассива равна 1
// Этап разбиения
int mid = left + (right - left) / 2; // Вычислить середину
mergeSort(nums, left, mid); // Рекурсивно обработать левый подмассив
mergeSort(nums, mid + 1, right); // Рекурсивно обработать правый подмассив
// Этап слияния
merge(nums, left, mid, right);
}
```
=== "Java"
```java title="merge_sort.java"
/* Объединить левый и правый подмассивы */
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);
}
```
=== "C#"
```csharp title="merge_sort.cs"
/* Объединить левый и правый подмассивы */
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);
}
```
=== "Go"
```go title="merge_sort.go"
/* Объединить левый и правый подмассивы */
func merge(nums []int, left, mid, right int) {
// Диапазон левого подмассива: [left, mid], диапазон правого подмассива: [mid+1, right]
// Создать временный массив tmp для хранения результата слияния
tmp := make([]int, right-left+1)
// Инициализировать начальные индексы левого и правого подмассивов
i, j, k := left, mid+1, 0
// Пока в левом и правом подмассивах еще есть элементы, сравнивать их и копировать меньший во временный массив
for i <= mid && j <= right {
if nums[i] <= nums[j] {
tmp[k] = nums[i]
i++
} else {
tmp[k] = nums[j]
j++
}
k++
}
// Скопировать оставшиеся элементы левого и правого подмассивов во временный массив
for i <= mid {
tmp[k] = nums[i]
i++
k++
}
for j <= right {
tmp[k] = nums[j]
j++
k++
}
// Скопировать элементы временного массива tmp обратно в соответствующий диапазон исходного массива nums
for k := 0; k < len(tmp); k++ {
nums[left+k] = tmp[k]
}
}
/* Сортировка слиянием */
func mergeSort(nums []int, left, right int) {
// Условие завершения
if left >= right {
return
}
// Этап разбиения
mid := left + (right - left) / 2
mergeSort(nums, left, mid)
mergeSort(nums, mid+1, right)
// Этап слияния
merge(nums, left, mid, right)
}
```
=== "Swift"
```swift title="merge_sort.swift"
/* Объединить левый и правый подмассивы */
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)
}
```
=== "JS"
```javascript title="merge_sort.js"
/* Объединить левый и правый подмассивы */
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);
}
```
=== "TS"
```typescript title="merge_sort.ts"
/* Объединить левый и правый подмассивы */
function merge(nums: number[], left: number, mid: number, right: number): void {
// Диапазон левого подмассива: [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: number[], left: number, right: number): void {
// Условие завершения
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);
}
```
=== "Dart"
```dart title="merge_sort.dart"
/* Объединить левый и правый подмассивы */
void merge(List<int> nums, int left, int mid, int right) {
// Диапазон левого подмассива: [left, mid], диапазон правого подмассива: [mid+1, right]
// Создать временный массив tmp для хранения результата слияния
List<int> tmp = List.filled(right - left + 1, 0);
// Инициализировать начальные индексы левого и правого подмассивов
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(List<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);
}
```
=== "Rust"
```rust title="merge_sort.rs"
/* Объединить левый и правый подмассивы */
fn merge(nums: &mut [i32], left: usize, mid: usize, right: usize) {
// Диапазон левого подмассива: [left, mid], диапазон правого подмассива: [mid+1, right]
// Создать временный массив tmp для хранения результата слияния
let tmp_size = right - left + 1;
let mut tmp = vec![0; tmp_size];
// Инициализировать начальные индексы левого и правого подмассивов
let (mut i, mut j, mut k) = (left, mid + 1, 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];
k += 1;
i += 1;
}
while j <= right {
tmp[k] = nums[j];
k += 1;
j += 1;
}
// Скопировать элементы временного массива tmp обратно в соответствующий диапазон исходного массива nums
for k in 0..tmp_size {
nums[left + k] = tmp[k];
}
}
/* Сортировка слиянием */
fn merge_sort(nums: &mut [i32], left: usize, right: usize) {
// Условие завершения
if left >= right {
return; // Завершить рекурсию, когда длина подмассива равна 1
}
// Этап разбиения
let mid = left + (right - left) / 2; // Вычислить середину
merge_sort(nums, left, mid); // Рекурсивно обработать левый подмассив
merge_sort(nums, mid + 1, right); // Рекурсивно обработать правый подмассив
// Этап слияния
merge(nums, left, mid, right);
}
```
=== "C"
```c title="merge_sort.c"
/* Объединить левый и правый подмассивы */
void merge(int *nums, int left, int mid, int right) {
// Диапазон левого подмассива: [left, mid], диапазон правого подмассива: [mid+1, right]
// Создать временный массив tmp для хранения результата слияния
int tmpSize = right - left + 1;
int *tmp = (int *)malloc(tmpSize * sizeof(int));
// Инициализировать начальные индексы левого и правого подмассивов
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 < tmpSize; ++k) {
nums[left + k] = tmp[k];
}
// Освободить память
free(tmp);
}
/* Сортировка слиянием */
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);
}
```
=== "Kotlin"
```kotlin title="merge_sort.kt"
/* Объединить левый и правый подмассивы */
fun merge(nums: IntArray, left: Int, mid: Int, right: Int) {
// Диапазон левого подмассива: [left, mid], диапазон правого подмассива: [mid+1, right]
// Создать временный массив tmp для хранения результата слияния
val tmp = IntArray(right - left + 1)
// Инициализировать начальные индексы левого и правого подмассивов
var i = left
var j = mid + 1
var 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 (l in tmp.indices) {
nums[left + l] = tmp[l]
}
}
/* Сортировка слиянием */
fun mergeSort(nums: IntArray, left: Int, right: Int) {
// Условие завершения
if (left >= right) return // Завершить рекурсию, когда длина подмассива равна 1
// Этап разбиения
val mid = left + (right - left) / 2 // Вычислить середину
mergeSort(nums, left, mid) // Рекурсивно обработать левый подмассив
mergeSort(nums, mid + 1, right) // Рекурсивно обработать правый подмассив
// Этап слияния
merge(nums, left, mid, right)
}
```
=== "Ruby"
```ruby title="merge_sort.rb"
=begin
File: merge_sort.rb
Created Time: 2024-04-10
Author: junminhong (junminhong1110@gmail.com)
=end
# ## Слияние левого и правого подмассивов ###
def merge(nums, left, mid, right)
# Интервал левого подмассива: [left, mid], правого подмассива: [mid+1, right]
# Создать временный массив tmp для хранения результата слияния
tmp = Array.new(right - left + 1, 0)
# Инициализировать начальные индексы левого и правого подмассивов
i, j, k = left, mid + 1, 0
# Пока в левом и правом подмассивах еще есть элементы, сравнивать их и копировать меньший во временный массив
while i <= mid && j <= right
if nums[i] <= nums[j]
tmp[k] = nums[i]
i += 1
else
tmp[k] = nums[j]
j += 1
end
k += 1
end
# Скопировать оставшиеся элементы левого и правого подмассивов во временный массив
while i <= mid
tmp[k] = nums[i]
i += 1
k += 1
end
while j <= right
tmp[k] = nums[j]
j += 1
k += 1
end
# Скопировать элементы временного массива tmp обратно в соответствующий диапазон исходного массива nums
(0...tmp.length).each do |k|
nums[left + k] = tmp[k]
end
end
=begin
File: merge_sort.rb
Created Time: 2024-04-10
Author: junminhong (junminhong1110@gmail.com)
=end
# ## Слияние левого и правого подмассивов ###
def merge(nums, left, mid, right)
# Интервал левого подмассива: [left, mid], правого подмассива: [mid+1, right]
# Создать временный массив tmp для хранения результата слияния
tmp = Array.new(right - left + 1, 0)
# Инициализировать начальные индексы левого и правого подмассивов
i, j, k = left, mid + 1, 0
# Пока в левом и правом подмассивах еще есть элементы, сравнивать их и копировать меньший во временный массив
while i <= mid && j <= right
if nums[i] <= nums[j]
tmp[k] = nums[i]
i += 1
else
tmp[k] = nums[j]
j += 1
end
k += 1
end
# Скопировать оставшиеся элементы левого и правого подмассивов во временный массив
while i <= mid
tmp[k] = nums[i]
i += 1
k += 1
end
while j <= right
tmp[k] = nums[j]
j += 1
k += 1
end
# Скопировать элементы временного массива tmp обратно в соответствующий диапазон исходного массива nums
(0...tmp.length).each do |k|
nums[left + k] = tmp[k]
end
end
# ## Сортировка слиянием ###
def merge_sort(nums, left, right)
# Условие завершения
# Когда длина подмассива равна 1, рекурсия завершается
return if left >= right
# Этап разбиения
mid = left + (right - left) / 2 # Вычислить середину
merge_sort(nums, left, mid) # Рекурсивно обработать левый подмассив
merge_sort(nums, mid + 1, right) # Рекурсивно обработать правый подмассив
# Этап слияния
merge(nums, left, mid, right)
end
```
??? pythontutor "Визуализация кода"
<div style="height: 549px; width: 100%;"><iframe class="pythontutor-iframe" src="https://pythontutor.com/iframe-embed.html#code=def%20merge%28nums%3A%20list%5Bint%5D%2C%20left%3A%20int%2C%20mid%3A%20int%2C%20right%3A%20int%29%3A%0A%20%20%20%20tmp%20%3D%20%5B0%5D%20%2A%20%28right%20-%20left%20%2B%201%29%0A%20%20%20%20%28i%2C%20j%2C%20k%29%20%3D%20%28left%2C%20mid%20%2B%201%2C%200%29%0A%20%20%20%20while%20i%20%3C%3D%20mid%20and%20j%20%3C%3D%20right%3A%0A%20%20%20%20%20%20%20%20if%20nums%5Bi%5D%20%3C%3D%20nums%5Bj%5D%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20tmp%5Bk%5D%20%3D%20nums%5Bi%5D%0A%20%20%20%20%20%20%20%20%20%20%20%20i%20%2B%3D%201%0A%20%20%20%20%20%20%20%20else%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20tmp%5Bk%5D%20%3D%20nums%5Bj%5D%0A%20%20%20%20%20%20%20%20%20%20%20%20j%20%2B%3D%201%0A%20%20%20%20%20%20%20%20k%20%2B%3D%201%0A%20%20%20%20while%20i%20%3C%3D%20mid%3A%0A%20%20%20%20%20%20%20%20tmp%5Bk%5D%20%3D%20nums%5Bi%5D%0A%20%20%20%20%20%20%20%20i%20%2B%3D%201%0A%20%20%20%20%20%20%20%20k%20%2B%3D%201%0A%20%20%20%20while%20j%20%3C%3D%20right%3A%0A%20%20%20%20%20%20%20%20tmp%5Bk%5D%20%3D%20nums%5Bj%5D%0A%20%20%20%20%20%20%20%20j%20%2B%3D%201%0A%20%20%20%20%20%20%20%20k%20%2B%3D%201%0A%20%20%20%20for%20k%20in%20range%280%2C%20len%28tmp%29%29%3A%0A%20%20%20%20%20%20%20%20nums%5Bleft%20%2B%20k%5D%20%3D%20tmp%5Bk%5D%0A%0Adef%20merge_sort%28nums%3A%20list%5Bint%5D%2C%20left%3A%20int%2C%20right%3A%20int%29%3A%0A%20%20%20%20if%20left%20%3E%3D%20right%3A%0A%20%20%20%20%20%20%20%20return%0A%20%20%20%20mid%20%3D%20%28left%20%2B%20right%29%20%2F%2F%202%0A%20%20%20%20merge_sort%28nums%2C%20left%2C%20mid%29%0A%20%20%20%20merge_sort%28nums%2C%20mid%20%2B%201%2C%20right%29%0A%20%20%20%20merge%28nums%2C%20left%2C%20mid%2C%20right%29%0A%27Driver%20Code%27%0Aif%20__name__%20%3D%3D%20%27__main__%27%3A%0A%20%20%20%20nums%20%3D%20%5B7%2C%203%2C%202%2C%206%2C%200%2C%201%2C%205%2C%204%5D%0A%20%20%20%20merge_sort%28nums%2C%200%2C%20len%28nums%29%20-%201%29%0A%20%20%20%20print%28%27%D0%9F%D0%BE%D1%81%D0%BB%D0%B5%20%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B8%20%D1%81%D0%BB%D0%B8%D1%8F%D0%BD%D0%B8%D0%B5%D0%BC%20nums%20%3D%27%2C%20nums%29&codeDivHeight=472&codeDivWidth=350&cumulative=false&curInstr=5&heapPrimitives=nevernest&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false"> </iframe></div>
<div style="margin-top: 5px;"><a href="https://pythontutor.com/iframe-embed.html#code=def%20merge%28nums%3A%20list%5Bint%5D%2C%20left%3A%20int%2C%20mid%3A%20int%2C%20right%3A%20int%29%3A%0A%20%20%20%20tmp%20%3D%20%5B0%5D%20%2A%20%28right%20-%20left%20%2B%201%29%0A%20%20%20%20%28i%2C%20j%2C%20k%29%20%3D%20%28left%2C%20mid%20%2B%201%2C%200%29%0A%20%20%20%20while%20i%20%3C%3D%20mid%20and%20j%20%3C%3D%20right%3A%0A%20%20%20%20%20%20%20%20if%20nums%5Bi%5D%20%3C%3D%20nums%5Bj%5D%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20tmp%5Bk%5D%20%3D%20nums%5Bi%5D%0A%20%20%20%20%20%20%20%20%20%20%20%20i%20%2B%3D%201%0A%20%20%20%20%20%20%20%20else%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20tmp%5Bk%5D%20%3D%20nums%5Bj%5D%0A%20%20%20%20%20%20%20%20%20%20%20%20j%20%2B%3D%201%0A%20%20%20%20%20%20%20%20k%20%2B%3D%201%0A%20%20%20%20while%20i%20%3C%3D%20mid%3A%0A%20%20%20%20%20%20%20%20tmp%5Bk%5D%20%3D%20nums%5Bi%5D%0A%20%20%20%20%20%20%20%20i%20%2B%3D%201%0A%20%20%20%20%20%20%20%20k%20%2B%3D%201%0A%20%20%20%20while%20j%20%3C%3D%20right%3A%0A%20%20%20%20%20%20%20%20tmp%5Bk%5D%20%3D%20nums%5Bj%5D%0A%20%20%20%20%20%20%20%20j%20%2B%3D%201%0A%20%20%20%20%20%20%20%20k%20%2B%3D%201%0A%20%20%20%20for%20k%20in%20range%280%2C%20len%28tmp%29%29%3A%0A%20%20%20%20%20%20%20%20nums%5Bleft%20%2B%20k%5D%20%3D%20tmp%5Bk%5D%0A%0Adef%20merge_sort%28nums%3A%20list%5Bint%5D%2C%20left%3A%20int%2C%20right%3A%20int%29%3A%0A%20%20%20%20if%20left%20%3E%3D%20right%3A%0A%20%20%20%20%20%20%20%20return%0A%20%20%20%20mid%20%3D%20%28left%20%2B%20right%29%20%2F%2F%202%0A%20%20%20%20merge_sort%28nums%2C%20left%2C%20mid%29%0A%20%20%20%20merge_sort%28nums%2C%20mid%20%2B%201%2C%20right%29%0A%20%20%20%20merge%28nums%2C%20left%2C%20mid%2C%20right%29%0A%27Driver%20Code%27%0Aif%20__name__%20%3D%3D%20%27__main__%27%3A%0A%20%20%20%20nums%20%3D%20%5B7%2C%203%2C%202%2C%206%2C%200%2C%201%2C%205%2C%204%5D%0A%20%20%20%20merge_sort%28nums%2C%200%2C%20len%28nums%29%20-%201%29%0A%20%20%20%20print%28%27%D0%9F%D0%BE%D1%81%D0%BB%D0%B5%20%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B8%20%D1%81%D0%BB%D0%B8%D1%8F%D0%BD%D0%B8%D0%B5%D0%BC%20nums%20%3D%27%2C%20nums%29&codeDivHeight=800&codeDivWidth=600&cumulative=false&curInstr=5&heapPrimitives=nevernest&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false" target="_blank" rel="noopener noreferrer">Во весь экран ></a></div>
## 11.6.2 &nbsp; Характеристики алгоритма
- **Временная сложность равна $O(n \log n)$, алгоритм не является адаптивным**: этап разделения создает дерево рекурсии высоты $\log n$ , а суммарное число операций слияния на каждом уровне равно $n$ , поэтому общая временная сложность составляет $O(n \log n)$ .
- **Пространственная сложность равна $O(n)$, сортировка не выполняется на месте**: глубина рекурсии равна $\log n$ , из-за чего требуется $O(\log n)$ памяти под стек вызовов. Для этапа слияния нужен вспомогательный массив, поэтому дополнительно используется $O(n)$ памяти.
- **Стабильная сортировка**: в процессе слияния относительный порядок равных элементов не меняется.
## 11.6.3 &nbsp; Сортировка связного списка
Для связных списков сортировка слиянием имеет заметное преимущество перед другими алгоритмами сортировки: **пространственную сложность задачи сортировки списка можно оптимизировать до $O(1)$**.
- **Этап разделения**: работу по разбиению списка можно реализовать с помощью "итерации" вместо "рекурсии", тем самым устранив расход памяти на стек вызовов.
- **Этап слияния**: в связном списке добавление и удаление узлов требует только изменения ссылок (указателей), поэтому при слиянии двух коротких упорядоченных списков в один длинный упорядоченный список не нужно создавать дополнительный список.
Детали реализации достаточно сложны; заинтересованные читатели могут изучить соответствующие материалы самостоятельно.
ru/docs/chapter_sorting/quick_sort.md
+1634
View File
File diff suppressed because one or more lines are too long
ru/docs/chapter_sorting/radix_sort.md
+788
View File
@@ -0,0 +1,788 @@
---
comments: true
---
# 11.10 &nbsp; Поразрядная сортировка
В предыдущем разделе мы познакомились с сортировкой подсчетом: она подходит для случаев, когда объем данных $n$ велик, а диапазон значений $m$ сравнительно мал. Предположим теперь, что нужно отсортировать $n = 10^6$ студенческих идентификаторов, причем каждый идентификатор является $8$-значным числом. Тогда диапазон данных $m = 10^8$ оказывается очень большим; сортировка подсчетом потребует огромного объема памяти, а поразрядная сортировка позволяет этого избежать.
<u>Поразрядная сортировка (radix sort)</u> по своей основной идее совпадает с сортировкой подсчетом и тоже реализует сортировку через подсчет количества. Поверх этого поразрядная сортировка использует иерархию разрядов числа и последовательно сортирует данные по каждому разряду, получая итоговый упорядоченный результат.
## 11.10.1 &nbsp; Алгоритм
Рассмотрим пример со студенческими номерами: будем считать, что младший разряд имеет номер $1$ , а старший - номер $8$ . Тогда процесс поразрядной сортировки показан на рисунке 11-18.
1. Инициализировать номер разряда $k = 1$ .
2. Выполнить "сортировку подсчетом" по $k$-му разряду студенческого номера. После этого данные будут упорядочены по $k$-му разряду по возрастанию.
3. Увеличить $k$ на $1$ и вернуться к шагу `2.` , продолжая процесс, пока сортировка не будет выполнена для всех разрядов.
![Процесс поразрядной сортировки](radix_sort.assets/radix_sort_overview.png){ class="animation-figure" }
<p align="center"> Рисунок 11-18 &nbsp; Процесс поразрядной сортировки </p>
Ниже разберем реализацию кода. Для числа $x$ в системе счисления с основанием $d$ получить его $k$-й разряд $x_k$ можно по формуле:
$$
x_k = \lfloor\frac{x}{d^{k-1}}\rfloor \bmod d
$$
где $\lfloor a \rfloor$ обозначает округление числа $a$ вниз, а $\bmod \: d$ означает взятие остатка по модулю $d$ . Для студенческих идентификаторов выполняется $d = 10$ и $k \in [1, 8]$ .
Кроме того, нам нужно слегка изменить код сортировки подсчетом, чтобы он мог сортировать числа по их $k$-му разряду:
=== "Python"
```python title="radix_sort.py"
def digit(num: int, exp: int) -> int:
"""Получить k-й разряд элемента num, где exp = 10^(k-1)"""
# Передача exp вместо k позволяет избежать повторного дорогостоящего вычисления степени
return (num // exp) % 10
def counting_sort_digit(nums: list[int], exp: int):
"""Сортировка подсчетом (сортировка по k-му разряду nums)"""
# Разряды десятичной системы лежат в диапазоне 0~9, поэтому нужен массив корзин длины 10
counter = [0] * 10
n = len(nums)
# Подсчитать число появлений каждой цифры от 0 до 9
for i in range(n):
d = digit(nums[i], exp) # Получить k-й разряд nums[i], обозначив его как d
counter[d] += 1 # Подсчитать число появлений цифры d
# Вычислить префиксные суммы и преобразовать «число появлений» в «индекс массива»
for i in range(1, 10):
counter[i] += counter[i - 1]
# Выполняя обратный проход, заполнить res элементами по статистике в корзинах
res = [0] * n
for i in range(n - 1, -1, -1):
d = digit(nums[i], exp)
j = counter[d] - 1 # Получить индекс j цифры d в массиве
res[j] = nums[i] # Поместить текущий элемент по индексу j
counter[d] -= 1 # Уменьшить количество d на 1
# Перезаписать исходный массив nums результатом
for i in range(n):
nums[i] = res[i]
def radix_sort(nums: list[int]):
"""Поразрядная сортировка"""
# Получить максимальный элемент массива, чтобы определить максимальное число разрядов
m = max(nums)
# Проходить разряды от младшего к старшему
exp = 1
while exp <= m:
# Выполнить сортировку подсчетом по k-му разряду элементов массива
# k = 1 -> exp = 1
# k = 2 -> exp = 10
# то есть exp = 10^(k-1)
counting_sort_digit(nums, exp)
exp *= 10
```
=== "C++"
```cpp title="radix_sort.cpp"
/* Получить k-й разряд элемента num, где exp = 10^(k-1) */
int digit(int num, int exp) {
// Передача exp вместо k позволяет избежать повторного дорогостоящего вычисления степени
return (num / exp) % 10;
}
/* Сортировка подсчетом (сортировка по k-му разряду nums) */
void countingSortDigit(vector<int> &nums, int exp) {
// Разряды десятичной системы лежат в диапазоне 0~9, поэтому нужен массив корзин длины 10
vector<int> counter(10, 0);
int n = nums.size();
// Подсчитать число появлений каждой цифры от 0 до 9
for (int i = 0; i < n; i++) {
int d = digit(nums[i], exp); // Получить k-й разряд nums[i], обозначив его как d
counter[d]++; // Подсчитать число появлений цифры d
}
// Вычислить префиксные суммы и преобразовать «число появлений» в «индекс массива»
for (int i = 1; i < 10; i++) {
counter[i] += counter[i - 1];
}
// Выполняя обратный проход, заполнить res элементами по статистике в корзинах
vector<int> res(n, 0);
for (int i = n - 1; i >= 0; i--) {
int d = digit(nums[i], exp);
int j = counter[d] - 1; // Получить индекс j цифры d в массиве
res[j] = nums[i]; // Поместить текущий элемент по индексу j
counter[d]--; // Уменьшить количество d на 1
}
// Перезаписать исходный массив nums результатом
for (int i = 0; i < n; i++)
nums[i] = res[i];
}
/* Поразрядная сортировка */
void radixSort(vector<int> &nums) {
// Получить максимальный элемент массива, чтобы определить максимальное число разрядов
int m = *max_element(nums.begin(), nums.end());
// Проходить разряды от младшего к старшему
for (int exp = 1; exp <= m; exp *= 10)
// Выполнить сортировку подсчетом по k-му разряду элементов массива
// k = 1 -> exp = 1
// k = 2 -> exp = 10
// то есть exp = 10^(k-1)
countingSortDigit(nums, exp);
}
```
=== "Java"
```java title="radix_sort.java"
/* Получить 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 = Integer.MIN_VALUE;
for (int num : 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);
}
}
```
=== "C#"
```csharp title="radix_sort.cs"
/* Получить 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);
}
}
```
=== "Go"
```go title="radix_sort.go"
/* Получить k-й разряд элемента num, где exp = 10^(k-1) */
func digit(num, exp int) int {
// Передача exp вместо k позволяет избежать повторного дорогостоящего вычисления степени
return (num / exp) % 10
}
/* Сортировка подсчетом (сортировка по k-му разряду nums) */
func countingSortDigit(nums []int, exp int) {
// Разряды десятичной системы лежат в диапазоне 0~9, поэтому нужен массив корзин длины 10
counter := make([]int, 10)
n := len(nums)
// Подсчитать число появлений каждой цифры от 0 до 9
for i := 0; i < n; i++ {
d := digit(nums[i], exp) // Получить k-й разряд nums[i], обозначив его как d
counter[d]++ // Подсчитать число появлений цифры d
}
// Вычислить префиксные суммы и преобразовать «число появлений» в «индекс массива»
for i := 1; i < 10; i++ {
counter[i] += counter[i-1]
}
// Выполняя обратный проход, заполнить res элементами по статистике в корзинах
res := make([]int, n)
for i := n - 1; i >= 0; i-- {
d := digit(nums[i], exp)
j := counter[d] - 1 // Получить индекс j цифры d в массиве
res[j] = nums[i] // Поместить текущий элемент по индексу j
counter[d]-- // Уменьшить количество d на 1
}
// Перезаписать исходный массив nums результатом
for i := 0; i < n; i++ {
nums[i] = res[i]
}
}
/* Поразрядная сортировка */
func radixSort(nums []int) {
// Получить максимальный элемент массива, чтобы определить максимальное число разрядов
max := math.MinInt
for _, num := range nums {
if num > max {
max = num
}
}
// Проходить разряды от младшего к старшему
for exp := 1; max >= exp; exp *= 10 {
// Выполнить сортировку подсчетом по k-му разряду элементов массива
// k = 1 -> exp = 1
// k = 2 -> exp = 10
// то есть exp = 10^(k-1)
countingSortDigit(nums, exp)
}
}
```
=== "Swift"
```swift title="radix_sort.swift"
/* Получить 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)
}
}
```
=== "JS"
```javascript title="radix_sort.js"
/* Получить 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);
}
}
```
=== "TS"
```typescript title="radix_sort.ts"
/* Получить k-й разряд элемента num, где exp = 10^(k-1) */
function digit(num: number, exp: number): number {
// Передача exp вместо k позволяет избежать повторного дорогостоящего вычисления степени
return Math.floor(num / exp) % 10;
}
/* Сортировка подсчетом (сортировка по k-му разряду nums) */
function countingSortDigit(nums: number[], exp: number): void {
// Разряды десятичной системы лежат в диапазоне 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: number[]): void {
// Получить максимальный элемент массива, чтобы определить максимальное число разрядов
let m: number = 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);
}
}
```
=== "Dart"
```dart title="radix_sort.dart"
/* Получить k-й разряд элемента _num, где exp = 10^(k-1) */
int digit(int _num, int exp) {
// Передача exp вместо k позволяет избежать повторного дорогостоящего вычисления степени
return (_num ~/ exp) % 10;
}
/* Сортировка подсчетом (сортировка по k-му разряду nums) */
void countingSortDigit(List<int> nums, int exp) {
// Разряды десятичной системы лежат в диапазоне 0~9, поэтому нужен массив корзин длины 10
List<int> counter = List<int>.filled(10, 0);
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 элементами по статистике в корзинах
List<int> res = List<int>.filled(n, 0);
for (int i = n - 1; i >= 0; i--) {
int d = digit(nums[i], exp);
int j = counter[d] - 1; // Получить индекс j цифры d в массиве
res[j] = nums[i]; // Поместить текущий элемент по индексу j
counter[d]--; // Уменьшить количество d на 1
}
// Перезаписать исходный массив nums результатом
for (int i = 0; i < n; i++) nums[i] = res[i];
}
/* Поразрядная сортировка */
void radixSort(List<int> nums) {
// Получить максимальный элемент массива, чтобы определить максимальное число разрядов
// В dart длина int составляет 64 бита
int m = -1 << 63;
for (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);
}
```
=== "Rust"
```rust title="radix_sort.rs"
/* Получить k-й разряд элемента num, где exp = 10^(k-1) */
fn digit(num: i32, exp: i32) -> usize {
// Передача exp вместо k позволяет избежать повторного дорогостоящего вычисления степени
return ((num / exp) % 10) as usize;
}
/* Сортировка подсчетом (сортировка по k-му разряду nums) */
fn counting_sort_digit(nums: &mut [i32], exp: i32) {
// Разряды десятичной системы лежат в диапазоне 0~9, поэтому нужен массив корзин длины 10
let mut counter = [0; 10];
let n = nums.len();
// Подсчитать число появлений каждой цифры от 0 до 9
for i in 0..n {
let d = digit(nums[i], exp); // Получить k-й разряд nums[i], обозначив его как d
counter[d] += 1; // Подсчитать число появлений цифры d
}
// Вычислить префиксные суммы и преобразовать «число появлений» в «индекс массива»
for i in 1..10 {
counter[i] += counter[i - 1];
}
// Выполняя обратный проход, заполнить res элементами по статистике в корзинах
let mut res = vec![0; n];
for i in (0..n).rev() {
let d = digit(nums[i], exp);
let j = counter[d] - 1; // Получить индекс j цифры d в массиве
res[j] = nums[i]; // Поместить текущий элемент по индексу j
counter[d] -= 1; // Уменьшить количество d на 1
}
// Перезаписать исходный массив nums результатом
nums.copy_from_slice(&res);
}
/* Поразрядная сортировка */
fn radix_sort(nums: &mut [i32]) {
// Получить максимальный элемент массива, чтобы определить максимальное число разрядов
let m = *nums.into_iter().max().unwrap();
// Проходить разряды от младшего к старшему
let mut exp = 1;
while exp <= m {
counting_sort_digit(nums, exp);
exp *= 10;
}
}
```
=== "C"
```c title="radix_sort.c"
/* Получить 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 size, int exp) {
// Разряды десятичной системы лежат в диапазоне 0~9, поэтому нужен массив корзин длины 10
int *counter = (int *)malloc((sizeof(int) * 10));
memset(counter, 0, sizeof(int) * 10); // Инициализировать нулем для последующего освобождения памяти
// Подсчитать число появлений каждой цифры от 0 до 9
for (int i = 0; i < size; i++) {
// Получить k-й разряд nums[i], обозначив его как d
int d = digit(nums[i], exp);
// Подсчитать число появлений цифры d
counter[d]++;
}
// Вычислить префиксные суммы и преобразовать «число появлений» в «индекс массива»
for (int i = 1; i < 10; i++) {
counter[i] += counter[i - 1];
}
// Выполняя обратный проход, заполнить res элементами по статистике в корзинах
int *res = (int *)malloc(sizeof(int) * size);
for (int i = size - 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 < size; i++) {
nums[i] = res[i];
}
// Освободить память
free(res);
free(counter);
}
/* Поразрядная сортировка */
void radixSort(int nums[], int size) {
// Получить максимальный элемент массива, чтобы определить максимальное число разрядов
int max = INT32_MIN;
for (int i = 0; i < size; i++) {
if (nums[i] > max) {
max = nums[i];
}
}
// Проходить разряды от младшего к старшему
for (int exp = 1; max >= exp; exp *= 10)
// Выполнить сортировку подсчетом по k-му разряду элементов массива
// k = 1 -> exp = 1
// k = 2 -> exp = 10
// то есть exp = 10^(k-1)
countingSortDigit(nums, size, exp);
}
```
=== "Kotlin"
```kotlin title="radix_sort.kt"
/* Получить k-й разряд элемента num, где exp = 10^(k-1) */
fun digit(num: Int, exp: Int): Int {
// Передача exp вместо k позволяет избежать повторного дорогостоящего вычисления степени
return (num / exp) % 10
}
/* Сортировка подсчетом (сортировка по k-му разряду nums) */
fun countingSortDigit(nums: IntArray, exp: Int) {
// Разряды десятичной системы лежат в диапазоне 0~9, поэтому нужен массив корзин длины 10
val counter = IntArray(10)
val n = nums.size
// Подсчитать число появлений каждой цифры от 0 до 9
for (i in 0..<n) {
val d = digit(nums[i], exp) // Получить k-й разряд nums[i], обозначив его как d
counter[d]++ // Подсчитать число появлений цифры d
}
// Вычислить префиксные суммы и преобразовать «число появлений» в «индекс массива»
for (i in 1..9) {
counter[i] += counter[i - 1]
}
// Выполняя обратный проход, заполнить res элементами по статистике в корзинах
val res = IntArray(n)
for (i in n - 1 downTo 0) {
val d = digit(nums[i], exp)
val j = counter[d] - 1 // Получить индекс j цифры d в массиве
res[j] = nums[i] // Поместить текущий элемент по индексу j
counter[d]-- // Уменьшить количество d на 1
}
// Перезаписать исходный массив nums результатом
for (i in 0..<n)
nums[i] = res[i]
}
/* Поразрядная сортировка */
fun radixSort(nums: IntArray) {
// Получить максимальный элемент массива, чтобы определить максимальное число разрядов
var m = Int.MIN_VALUE
for (num in nums) if (num > m) m = num
var exp = 1
// Проходить разряды от младшего к старшему
while (exp <= m) {
// Выполнить сортировку подсчетом по k-му разряду элементов массива
// k = 1 -> exp = 1
// k = 2 -> exp = 10
// то есть exp = 10^(k-1)
countingSortDigit(nums, exp)
exp *= 10
}
}
```
=== "Ruby"
```ruby title="radix_sort.rb"
=begin
File: radix_sort.rb
Created Time: 2024-05-03
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
=end
# ## Получить k-й разряд элемента num, где exp = 10^(k-1) ###
def digit(num, exp)
# Передача exp вместо k позволяет избежать повторного выполнения дорогостоящих вычислений степени
(num / exp) % 10
end
=begin
File: radix_sort.rb
Created Time: 2024-05-03
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
=end
# ## Получить k-й разряд элемента num, где exp = 10^(k-1) ###
def digit(num, exp)
# Передача exp вместо k позволяет избежать повторного выполнения дорогостоящих вычислений степени
(num / exp) % 10
end
# ## Сортировка подсчетом (сортировка по k-му разряду nums) ###
def counting_sort_digit(nums, exp)
# Разряды десятичной системы лежат в диапазоне 0~9, поэтому нужен массив корзин длины 10
counter = Array.new(10, 0)
n = nums.length
# Подсчитать число появлений каждой цифры от 0 до 9
for i in 0...n
d = digit(nums[i], exp) # Получить k-й разряд nums[i], обозначив его как d
counter[d] += 1 # Подсчитать число появлений цифры d
end
# Вычислить префиксные суммы и преобразовать «число появлений» в «индекс массива»
(1...10).each { |i| counter[i] += counter[i - 1] }
# Выполняя обратный проход, заполнить res элементами по статистике в корзинах
res = Array.new(n, 0)
for i in (n - 1).downto(0)
d = digit(nums[i], exp)
j = counter[d] - 1 # Получить индекс j цифры d в массиве
res[j] = nums[i] # Поместить текущий элемент по индексу j
counter[d] -= 1 # Уменьшить количество d на 1
end
# Перезаписать исходный массив nums результатом
(0...n).each { |i| nums[i] = res[i] }
end
=begin
File: radix_sort.rb
Created Time: 2024-05-03
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
=end
# ## Получить k-й разряд элемента num, где exp = 10^(k-1) ###
def digit(num, exp)
# Передача exp вместо k позволяет избежать повторного выполнения дорогостоящих вычислений степени
(num / exp) % 10
end
# ## Сортировка подсчетом (сортировка по k-му разряду nums) ###
def counting_sort_digit(nums, exp)
# Разряды десятичной системы лежат в диапазоне 0~9, поэтому нужен массив корзин длины 10
counter = Array.new(10, 0)
n = nums.length
# Подсчитать число появлений каждой цифры от 0 до 9
for i in 0...n
d = digit(nums[i], exp) # Получить k-й разряд nums[i], обозначив его как d
counter[d] += 1 # Подсчитать число появлений цифры d
end
# Вычислить префиксные суммы и преобразовать «число появлений» в «индекс массива»
(1...10).each { |i| counter[i] += counter[i - 1] }
# Выполняя обратный проход, заполнить res элементами по статистике в корзинах
res = Array.new(n, 0)
for i in (n - 1).downto(0)
d = digit(nums[i], exp)
j = counter[d] - 1 # Получить индекс j цифры d в массиве
res[j] = nums[i] # Поместить текущий элемент по индексу j
counter[d] -= 1 # Уменьшить количество d на 1
end
# Перезаписать исходный массив nums результатом
(0...n).each { |i| nums[i] = res[i] }
end
# ## Поразрядная сортировка ###
def radix_sort(nums)
# Получить максимальный элемент массива, чтобы определить максимальное число разрядов
m = nums.max
# Проходить разряды от младшего к старшему
exp = 1
while exp <= m
# Выполнить сортировку подсчетом по k-му разряду элементов массива
# k = 1 -> exp = 1
# k = 2 -> exp = 10
# то есть exp = 10^(k-1)
counting_sort_digit(nums, exp)
exp *= 10
end
end
```
??? pythontutor "Визуализация кода"
<div style="height: 549px; width: 100%;"><iframe class="pythontutor-iframe" src="https://pythontutor.com/iframe-embed.html#code=def%20digit%28num%3A%20int%2C%20exp%3A%20int%29%20-%3E%20int%3A%0A%20%20%20%20return%20num%20%2F%2F%20exp%20%25%2010%0A%0Adef%20counting_sort_digit%28nums%3A%20list%5Bint%5D%2C%20exp%3A%20int%29%3A%0A%20%20%20%20counter%20%3D%20%5B0%5D%20%2A%2010%0A%20%20%20%20n%20%3D%20len%28nums%29%0A%20%20%20%20for%20i%20in%20range%28n%29%3A%0A%20%20%20%20%20%20%20%20d%20%3D%20digit%28nums%5Bi%5D%2C%20exp%29%0A%20%20%20%20%20%20%20%20counter%5Bd%5D%20%2B%3D%201%0A%20%20%20%20for%20i%20in%20range%281%2C%2010%29%3A%0A%20%20%20%20%20%20%20%20counter%5Bi%5D%20%2B%3D%20counter%5Bi%20-%201%5D%0A%20%20%20%20res%20%3D%20%5B0%5D%20%2A%20n%0A%20%20%20%20for%20i%20in%20range%28n%20-%201%2C%20-1%2C%20-1%29%3A%0A%20%20%20%20%20%20%20%20d%20%3D%20digit%28nums%5Bi%5D%2C%20exp%29%0A%20%20%20%20%20%20%20%20j%20%3D%20counter%5Bd%5D%20-%201%0A%20%20%20%20%20%20%20%20res%5Bj%5D%20%3D%20nums%5Bi%5D%0A%20%20%20%20%20%20%20%20counter%5Bd%5D%20-%3D%201%0A%20%20%20%20for%20i%20in%20range%28n%29%3A%0A%20%20%20%20%20%20%20%20nums%5Bi%5D%20%3D%20res%5Bi%5D%0A%0Adef%20radix_sort%28nums%3A%20list%5Bint%5D%29%3A%0A%20%20%20%20m%20%3D%20max%28nums%29%0A%20%20%20%20exp%20%3D%201%0A%20%20%20%20while%20exp%20%3C%3D%20m%3A%0A%20%20%20%20%20%20%20%20counting_sort_digit%28nums%2C%20exp%29%0A%20%20%20%20%20%20%20%20exp%20%2A%3D%2010%0A%27Driver%20Code%27%0Aif%20__name__%20%3D%3D%20%27__main__%27%3A%0A%20%20%20%20nums%20%3D%20%5B105%2C%20356%2C%20428%2C%20348%2C%20818%5D%0A%20%20%20%20radix_sort%28nums%29%0A%20%20%20%20print%28%27%D0%9F%D0%BE%D1%81%D0%BB%D0%B5%20%D0%BF%D0%BE%D1%80%D0%B0%D0%B7%D1%80%D1%8F%D0%B4%D0%BD%D0%BE%D0%B9%20%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B8%20nums%20%3D%27%2C%20nums%29&codeDivHeight=472&codeDivWidth=350&cumulative=false&curInstr=6&heapPrimitives=nevernest&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false"> </iframe></div>
<div style="margin-top: 5px;"><a href="https://pythontutor.com/iframe-embed.html#code=def%20digit%28num%3A%20int%2C%20exp%3A%20int%29%20-%3E%20int%3A%0A%20%20%20%20return%20num%20%2F%2F%20exp%20%25%2010%0A%0Adef%20counting_sort_digit%28nums%3A%20list%5Bint%5D%2C%20exp%3A%20int%29%3A%0A%20%20%20%20counter%20%3D%20%5B0%5D%20%2A%2010%0A%20%20%20%20n%20%3D%20len%28nums%29%0A%20%20%20%20for%20i%20in%20range%28n%29%3A%0A%20%20%20%20%20%20%20%20d%20%3D%20digit%28nums%5Bi%5D%2C%20exp%29%0A%20%20%20%20%20%20%20%20counter%5Bd%5D%20%2B%3D%201%0A%20%20%20%20for%20i%20in%20range%281%2C%2010%29%3A%0A%20%20%20%20%20%20%20%20counter%5Bi%5D%20%2B%3D%20counter%5Bi%20-%201%5D%0A%20%20%20%20res%20%3D%20%5B0%5D%20%2A%20n%0A%20%20%20%20for%20i%20in%20range%28n%20-%201%2C%20-1%2C%20-1%29%3A%0A%20%20%20%20%20%20%20%20d%20%3D%20digit%28nums%5Bi%5D%2C%20exp%29%0A%20%20%20%20%20%20%20%20j%20%3D%20counter%5Bd%5D%20-%201%0A%20%20%20%20%20%20%20%20res%5Bj%5D%20%3D%20nums%5Bi%5D%0A%20%20%20%20%20%20%20%20counter%5Bd%5D%20-%3D%201%0A%20%20%20%20for%20i%20in%20range%28n%29%3A%0A%20%20%20%20%20%20%20%20nums%5Bi%5D%20%3D%20res%5Bi%5D%0A%0Adef%20radix_sort%28nums%3A%20list%5Bint%5D%29%3A%0A%20%20%20%20m%20%3D%20max%28nums%29%0A%20%20%20%20exp%20%3D%201%0A%20%20%20%20while%20exp%20%3C%3D%20m%3A%0A%20%20%20%20%20%20%20%20counting_sort_digit%28nums%2C%20exp%29%0A%20%20%20%20%20%20%20%20exp%20%2A%3D%2010%0A%27Driver%20Code%27%0Aif%20__name__%20%3D%3D%20%27__main__%27%3A%0A%20%20%20%20nums%20%3D%20%5B105%2C%20356%2C%20428%2C%20348%2C%20818%5D%0A%20%20%20%20radix_sort%28nums%29%0A%20%20%20%20print%28%27%D0%9F%D0%BE%D1%81%D0%BB%D0%B5%20%D0%BF%D0%BE%D1%80%D0%B0%D0%B7%D1%80%D1%8F%D0%B4%D0%BD%D0%BE%D0%B9%20%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B8%20nums%20%3D%27%2C%20nums%29&codeDivHeight=800&codeDivWidth=600&cumulative=false&curInstr=6&heapPrimitives=nevernest&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false" target="_blank" rel="noopener noreferrer">Во весь экран ></a></div>
!!! question "Почему сортировка выполняется от младшего разряда к старшему?"
В последовательных раундах сортировки результаты более позднего раунда перекрывают результаты предыдущего. Например, если после первого раунда получилось $a < b$ , а после второго - $a > b$ , то именно результат второго раунда станет окончательным. Поскольку старшие разряды имеют более высокий приоритет, сначала нужно сортировать по младшим разрядам, а затем по старшим.
## 11.10.2 &nbsp; Характеристики алгоритма
По сравнению с сортировкой подсчетом поразрядная сортировка подходит для случаев с большим диапазоном чисел, **но только при условии, что данные можно представить в виде чисел фиксированной длины и число разрядов не слишком велико**. Например, числа с плавающей запятой плохо подходят для поразрядной сортировки, потому что число разрядов $k$ слишком велико и может привести к ситуации $O(nk) \gg O(n^2)$ .
- **Временная сложность равна $O(nk)$, алгоритм не является адаптивным**: пусть объем данных равен $n$ , числа записаны в системе счисления с основанием $d$ , а максимальное число разрядов равно $k$ . Тогда выполнение сортировки подсчетом для одного разряда требует $O(n + d)$ времени, а сортировка по всем $k$ разрядам требует $O((n + d)k)$ времени. Обычно $d$ и $k$ сравнительно малы, поэтому временная сложность стремится к $O(n)$ .
- **Пространственная сложность равна $O(n + d)$, сортировка не выполняется на месте**: как и в сортировке подсчетом, здесь требуются массивы `res` и `counter` длины $n$ и $d$ .
- **Стабильная сортировка**: если сортировка подсчетом стабильна, то и поразрядная сортировка стабильна; если же сортировка подсчетом нестабильна, поразрядная сортировка не может гарантировать корректный результат.
ru/docs/chapter_sorting/selection_sort.md
+346
View File
@@ -0,0 +1,346 @@
---
comments: true
---
# 11.2 &nbsp; Сортировка выбором
<u>Сортировка выбором (selection sort)</u> работает очень просто: запускается цикл, и на каждом шаге из неотсортированного диапазона выбирается минимальный элемент, после чего он переносится в конец уже отсортированного диапазона.
Пусть длина массива равна $n$ ; тогда процесс сортировки выбором выглядит так, как показано на рисунке 11-2.
1. В начальном состоянии все элементы не отсортированы, то есть неотсортированный диапазон индексов равен $[0, n-1]$ .
2. Выбрать минимальный элемент из диапазона $[0, n-1]$ и поменять его местами с элементом в позиции $0$ . После этого первые 1 элементов массива отсортированы.
3. Выбрать минимальный элемент из диапазона $[1, n-1]$ и поменять его местами с элементом в позиции $1$ . После этого первые 2 элементов массива отсортированы.
4. Продолжать по аналогии. После $n - 1$ раундов выбора и обмена первые $n - 1$ элементов массива будут отсортированы.
5. Оставшийся элемент обязательно является максимальным, сортировать его не нужно, поэтому массив считается отсортированным.
=== "<1>"
![Шаги сортировки выбором](selection_sort.assets/selection_sort_step1.png){ class="animation-figure" }
=== "<2>"
![selection_sort_step2](selection_sort.assets/selection_sort_step2.png){ class="animation-figure" }
=== "<3>"
![selection_sort_step3](selection_sort.assets/selection_sort_step3.png){ class="animation-figure" }
=== "<4>"
![selection_sort_step4](selection_sort.assets/selection_sort_step4.png){ class="animation-figure" }
=== "<5>"
![selection_sort_step5](selection_sort.assets/selection_sort_step5.png){ class="animation-figure" }
=== "<6>"
![selection_sort_step6](selection_sort.assets/selection_sort_step6.png){ class="animation-figure" }
=== "<7>"
![selection_sort_step7](selection_sort.assets/selection_sort_step7.png){ class="animation-figure" }
=== "<8>"
![selection_sort_step8](selection_sort.assets/selection_sort_step8.png){ class="animation-figure" }
=== "<9>"
![selection_sort_step9](selection_sort.assets/selection_sort_step9.png){ class="animation-figure" }
=== "<10>"
![selection_sort_step10](selection_sort.assets/selection_sort_step10.png){ class="animation-figure" }
=== "<11>"
![selection_sort_step11](selection_sort.assets/selection_sort_step11.png){ class="animation-figure" }
<p align="center"> Рисунок 11-2 &nbsp; Шаги сортировки выбором </p>
В коде мы используем $k$ для записи минимального элемента в пределах неотсортированного диапазона:
=== "Python"
```python title="selection_sort.py"
def selection_sort(nums: list[int]):
"""Сортировка выбором"""
n = len(nums)
# Внешний цикл: неотсортированный диапазон [i, n-1]
for i in range(n - 1):
# Внутренний цикл: найти минимальный элемент в неотсортированном диапазоне
k = i
for j in range(i + 1, n):
if nums[j] < nums[k]:
k = j # Записать индекс минимального элемента
# Поменять этот минимальный элемент местами с первым элементом неотсортированного диапазона
nums[i], nums[k] = nums[k], nums[i]
```
=== "C++"
```cpp title="selection_sort.cpp"
/* Сортировка выбором */
void selectionSort(vector<int> &nums) {
int n = nums.size();
// Внешний цикл: неотсортированный диапазон [i, n-1]
for (int i = 0; i < n - 1; i++) {
// Внутренний цикл: найти минимальный элемент в неотсортированном диапазоне
int k = i;
for (int j = i + 1; j < n; j++) {
if (nums[j] < nums[k])
k = j; // Записать индекс минимального элемента
}
// Поменять этот минимальный элемент местами с первым элементом неотсортированного диапазона
swap(nums[i], nums[k]);
}
}
```
=== "Java"
```java title="selection_sort.java"
/* Сортировка выбором */
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; // Записать индекс минимального элемента
}
// Поменять этот минимальный элемент местами с первым элементом неотсортированного диапазона
int temp = nums[i];
nums[i] = nums[k];
nums[k] = temp;
}
}
```
=== "C#"
```csharp title="selection_sort.cs"
/* Сортировка выбором */
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]);
}
}
```
=== "Go"
```go title="selection_sort.go"
/* Сортировка выбором */
func selectionSort(nums []int) {
n := len(nums)
// Внешний цикл: неотсортированный диапазон [i, n-1]
for i := 0; i < n-1; i++ {
// Внутренний цикл: найти минимальный элемент в неотсортированном диапазоне
k := i
for j := i + 1; j < n; j++ {
if nums[j] < nums[k] {
// Записать индекс минимального элемента
k = j
}
}
// Поменять этот минимальный элемент местами с первым элементом неотсортированного диапазона
nums[i], nums[k] = nums[k], nums[i]
}
}
```
=== "Swift"
```swift title="selection_sort.swift"
/* Сортировка выбором */
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)
}
}
```
=== "JS"
```javascript title="selection_sort.js"
/* Сортировка выбором */
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]];
}
}
```
=== "TS"
```typescript title="selection_sort.ts"
/* Сортировка выбором */
function selectionSort(nums: number[]): void {
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]];
}
}
```
=== "Dart"
```dart title="selection_sort.dart"
/* Сортировка выбором */
void selectionSort(List<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; // Записать индекс минимального элемента
}
// Поменять этот минимальный элемент местами с первым элементом неотсортированного диапазона
int temp = nums[i];
nums[i] = nums[k];
nums[k] = temp;
}
}
```
=== "Rust"
```rust title="selection_sort.rs"
/* Сортировка выбором */
fn selection_sort(nums: &mut [i32]) {
if nums.is_empty() {
return;
}
let n = nums.len();
// Внешний цикл: неотсортированный диапазон [i, n-1]
for i in 0..n - 1 {
// Внутренний цикл: найти минимальный элемент в неотсортированном диапазоне
let mut k = i;
for j in i + 1..n {
if nums[j] < nums[k] {
k = j; // Записать индекс минимального элемента
}
}
// Поменять этот минимальный элемент местами с первым элементом неотсортированного диапазона
nums.swap(i, k);
}
}
```
=== "C"
```c title="selection_sort.c"
/* Сортировка выбором */
void selectionSort(int nums[], int n) {
// Внешний цикл: неотсортированный диапазон [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; // Записать индекс минимального элемента
}
// Поменять этот минимальный элемент местами с первым элементом неотсортированного диапазона
int temp = nums[i];
nums[i] = nums[k];
nums[k] = temp;
}
}
```
=== "Kotlin"
```kotlin title="selection_sort.kt"
/* Сортировка выбором */
fun selectionSort(nums: IntArray) {
val n = nums.size
// Внешний цикл: неотсортированный диапазон [i, n-1]
for (i in 0..<n - 1) {
var k = i
// Внутренний цикл: найти минимальный элемент в неотсортированном диапазоне
for (j in i + 1..<n) {
if (nums[j] < nums[k])
k = j // Записать индекс минимального элемента
}
// Поменять этот минимальный элемент местами с первым элементом неотсортированного диапазона
val temp = nums[i]
nums[i] = nums[k]
nums[k] = temp
}
}
```
=== "Ruby"
```ruby title="selection_sort.rb"
=begin
File: selection_sort.rb
Created Time: 2024-05-03
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
=end
# ## Сортировка выбором ###
def selection_sort(nums)
n = nums.length
# Внешний цикл: неотсортированный диапазон [i, n-1]
for i in 0...(n - 1)
# Внутренний цикл: найти минимальный элемент в неотсортированном диапазоне
k = i
for j in (i + 1)...n
if nums[j] < nums[k]
k = j # Записать индекс минимального элемента
end
end
# Поменять этот минимальный элемент местами с первым элементом неотсортированного диапазона
nums[i], nums[k] = nums[k], nums[i]
end
end
```
??? pythontutor "Визуализация кода"
<div style="height: 531px; width: 100%;"><iframe class="pythontutor-iframe" src="https://pythontutor.com/iframe-embed.html#code=def%20selection_sort%28nums%3A%20list%5Bint%5D%29%3A%0A%20%20%20%20%22%22%22%D0%A1%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0%20%D0%B2%D1%8B%D0%B1%D0%BE%D1%80%D0%BE%D0%BC%22%22%22%0A%20%20%20%20n%20%3D%20len%28nums%29%0A%20%20%20%20%23%20%D0%92%D0%BD%D0%B5%D1%88%D0%BD%D0%B8%D0%B9%20%D1%86%D0%B8%D0%BA%D0%BB%3A%20%D0%BD%D0%B5%D0%BE%D1%82%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D1%8B%D0%B9%20%D0%B4%D0%B8%D0%B0%D0%BF%D0%B0%D0%B7%D0%BE%D0%BD%20%5Bi%2C%20n-1%5D%0A%20%20%20%20for%20i%20in%20range%28n%20-%201%29%3A%0A%20%20%20%20%20%20%20%20%23%20%D0%92%D0%BD%D1%83%D1%82%D1%80%D0%B5%D0%BD%D0%BD%D0%B8%D0%B9%20%D1%86%D0%B8%D0%BA%D0%BB%3A%20%D0%BD%D0%B0%D0%B9%D1%82%D0%B8%20%D0%BC%D0%B8%D0%BD%D0%B8%D0%BC%D0%B0%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%B2%20%D0%BD%D0%B5%D0%BE%D1%82%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%BC%20%D0%B4%D0%B8%D0%B0%D0%BF%D0%B0%D0%B7%D0%BE%D0%BD%D0%B5%0A%20%20%20%20%20%20%20%20k%20%3D%20i%0A%20%20%20%20%20%20%20%20for%20j%20in%20range%28i%20%2B%201%2C%20n%29%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20if%20nums%5Bj%5D%20%3C%20nums%5Bk%5D%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20k%20%3D%20j%20%20%23%20%D0%97%D0%B0%D0%BF%D0%B8%D1%81%D0%B0%D1%82%D1%8C%20%D0%B8%D0%BD%D0%B4%D0%B5%D0%BA%D1%81%20%D0%BC%D0%B8%D0%BD%D0%B8%D0%BC%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B3%D0%BE%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D0%B0%0A%20%20%20%20%20%20%20%20%23%20%D0%9F%D0%BE%D0%BC%D0%B5%D0%BD%D1%8F%D1%82%D1%8C%20%D1%8D%D1%82%D0%BE%D1%82%20%D0%BC%D0%B8%D0%BD%D0%B8%D0%BC%D0%B0%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%BC%D0%B5%D1%81%D1%82%D0%B0%D0%BC%D0%B8%20%D1%81%20%D0%BF%D0%B5%D1%80%D0%B2%D1%8B%D0%BC%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D0%BE%D0%BC%20%D0%BD%D0%B5%D0%BE%D1%82%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%B3%D0%BE%20%D0%B4%D0%B8%D0%B0%D0%BF%D0%B0%D0%B7%D0%BE%D0%BD%D0%B0%0A%20%20%20%20%20%20%20%20nums%5Bi%5D%2C%20nums%5Bk%5D%20%3D%20nums%5Bk%5D%2C%20nums%5Bi%5D%0A%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20nums%20%3D%20%5B4%2C%201%2C%203%2C%201%2C%205%2C%202%5D%0A%20%20%20%20selection_sort%28nums%29%0A%20%20%20%20print%28%22%D0%9F%D0%BE%D1%81%D0%BB%D0%B5%20%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B8%20%D0%B2%D1%8B%D0%B1%D0%BE%D1%80%D0%BE%D0%BC%20nums%20%3D%22%2C%20nums%29&codeDivHeight=472&codeDivWidth=350&cumulative=false&curInstr=4&heapPrimitives=nevernest&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false"> </iframe></div>
<div style="margin-top: 5px;"><a href="https://pythontutor.com/iframe-embed.html#code=def%20selection_sort%28nums%3A%20list%5Bint%5D%29%3A%0A%20%20%20%20%22%22%22%D0%A1%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0%20%D0%B2%D1%8B%D0%B1%D0%BE%D1%80%D0%BE%D0%BC%22%22%22%0A%20%20%20%20n%20%3D%20len%28nums%29%0A%20%20%20%20%23%20%D0%92%D0%BD%D0%B5%D1%88%D0%BD%D0%B8%D0%B9%20%D1%86%D0%B8%D0%BA%D0%BB%3A%20%D0%BD%D0%B5%D0%BE%D1%82%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D1%8B%D0%B9%20%D0%B4%D0%B8%D0%B0%D0%BF%D0%B0%D0%B7%D0%BE%D0%BD%20%5Bi%2C%20n-1%5D%0A%20%20%20%20for%20i%20in%20range%28n%20-%201%29%3A%0A%20%20%20%20%20%20%20%20%23%20%D0%92%D0%BD%D1%83%D1%82%D1%80%D0%B5%D0%BD%D0%BD%D0%B8%D0%B9%20%D1%86%D0%B8%D0%BA%D0%BB%3A%20%D0%BD%D0%B0%D0%B9%D1%82%D0%B8%20%D0%BC%D0%B8%D0%BD%D0%B8%D0%BC%D0%B0%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%B2%20%D0%BD%D0%B5%D0%BE%D1%82%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%BC%20%D0%B4%D0%B8%D0%B0%D0%BF%D0%B0%D0%B7%D0%BE%D0%BD%D0%B5%0A%20%20%20%20%20%20%20%20k%20%3D%20i%0A%20%20%20%20%20%20%20%20for%20j%20in%20range%28i%20%2B%201%2C%20n%29%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20if%20nums%5Bj%5D%20%3C%20nums%5Bk%5D%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20k%20%3D%20j%20%20%23%20%D0%97%D0%B0%D0%BF%D0%B8%D1%81%D0%B0%D1%82%D1%8C%20%D0%B8%D0%BD%D0%B4%D0%B5%D0%BA%D1%81%20%D0%BC%D0%B8%D0%BD%D0%B8%D0%BC%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B3%D0%BE%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D0%B0%0A%20%20%20%20%20%20%20%20%23%20%D0%9F%D0%BE%D0%BC%D0%B5%D0%BD%D1%8F%D1%82%D1%8C%20%D1%8D%D1%82%D0%BE%D1%82%20%D0%BC%D0%B8%D0%BD%D0%B8%D0%BC%D0%B0%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%BC%D0%B5%D1%81%D1%82%D0%B0%D0%BC%D0%B8%20%D1%81%20%D0%BF%D0%B5%D1%80%D0%B2%D1%8B%D0%BC%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D0%BE%D0%BC%20%D0%BD%D0%B5%D0%BE%D1%82%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%B3%D0%BE%20%D0%B4%D0%B8%D0%B0%D0%BF%D0%B0%D0%B7%D0%BE%D0%BD%D0%B0%0A%20%20%20%20%20%20%20%20nums%5Bi%5D%2C%20nums%5Bk%5D%20%3D%20nums%5Bk%5D%2C%20nums%5Bi%5D%0A%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20nums%20%3D%20%5B4%2C%201%2C%203%2C%201%2C%205%2C%202%5D%0A%20%20%20%20selection_sort%28nums%29%0A%20%20%20%20print%28%22%D0%9F%D0%BE%D1%81%D0%BB%D0%B5%20%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B8%20%D0%B2%D1%8B%D0%B1%D0%BE%D1%80%D0%BE%D0%BC%20nums%20%3D%22%2C%20nums%29&codeDivHeight=800&codeDivWidth=600&cumulative=false&curInstr=4&heapPrimitives=nevernest&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false" target="_blank" rel="noopener noreferrer">Во весь экран ></a></div>
## 11.2.1 &nbsp; Характеристики алгоритма
- **Временная сложность равна $O(n^2)$, сортировка не является адаптивной**: внешний цикл выполняется $n - 1$ раз; в первом раунде длина неотсортированного диапазона равна $n$ , а в последнем - $2$ , то есть отдельные раунды содержат $n$, $n - 1$, $\dots$, $3$, $2$ проходов внутреннего цикла, их сумма равна $\frac{(n - 1)(n + 2)}{2}$ .
- **Пространственная сложность равна $O(1)$, сортировка выполняется на месте**: указатели $i$ и $j$ используют константный объем дополнительной памяти.
- **Нестабильная сортировка**: как показано на рисунке 11-3, элемент `nums[i]` может быть переставлен вправо от другого равного ему элемента, из-за чего их относительный порядок изменится.
![Пример нестабильности сортировки выбором](selection_sort.assets/selection_sort_instability.png){ class="animation-figure" }
<p align="center"> Рисунок 11-3 &nbsp; Пример нестабильности сортировки выбором </p>
ru/docs/chapter_sorting/sorting_algorithm.md
+52
View File
@@ -0,0 +1,52 @@
---
comments: true
---
# 11.1 &nbsp; Алгоритмы сортировки
<u>Алгоритмы сортировки (sorting algorithm)</u> используются для упорядочивания набора данных по определенному правилу. Они применяются очень широко, потому что упорядоченные данные обычно проще и быстрее искать, анализировать и обрабатывать.
Как показано на рисунке 11-1, данными в алгоритмах сортировки могут быть целые числа, числа с плавающей запятой, символы, строки и другие типы. Критерий сравнения тоже можно задать по-разному, например по величине чисел, по порядку ASCII-кодов символов или по пользовательскому правилу.
![Примеры типов данных и правил сравнения](sorting_algorithm.assets/sorting_examples.png){ class="animation-figure" }
<p align="center"> Рисунок 11-1 &nbsp; Примеры типов данных и правил сравнения </p>
## 11.1.1 &nbsp; Критерии оценки
**Скорость выполнения**: мы ожидаем, что временная сложность алгоритма сортировки будет как можно ниже, а общее число операций будет как можно меньше (то есть константа во временной сложности будет небольшой). Для больших объемов данных этот критерий особенно важен.
**Сортировка на месте**: как следует из названия, <u>сортировка на месте</u> выполняется прямо в исходном массиве и не требует дополнительного вспомогательного массива, что позволяет экономить память. Обычно при сортировке на месте переносов данных меньше, а скорость работы выше.
**Стабильность**: <u>стабильная сортировка</u> после завершения не меняет относительный порядок одинаковых элементов в массиве.
Стабильность является необходимым условием для многоуровневой сортировки. Предположим, у нас есть таблица со сведениями о студентах, где в первом и втором столбцах записаны имя и возраст. В этом случае <u>нестабильная сортировка</u> может разрушить уже существующий порядок входных данных:
```shell
# Входные данные уже отсортированы по имени
# (name, age)
('A', 19)
('B', 18)
('C', 21)
('D', 19)
('E', 23)
# Если затем нестабильным алгоритмом отсортировать список по возрасту,
# относительный порядок ('D', 19) и ('A', 19) изменится,
# и свойство упорядоченности по имени будет потеряно
('B', 18)
('D', 19)
('A', 19)
('C', 21)
('E', 23)
```
**Адаптивность**: <u>адаптивная сортировка</u> умеет использовать уже существующий порядок входных данных, чтобы сократить вычисления и добиться лучшей эффективности. Лучшая временная сложность адаптивных алгоритмов обычно лучше их средней временной сложности.
**Основанность на сравнении**: <u>сортировка на основе сравнений</u> использует операторы сравнения ($<$, $=$, $>$), чтобы определить относительный порядок элементов и отсортировать массив; ее теоретически лучшая временная сложность равна $O(n \log n)$ . А вот <u>сортировка без сравнений</u> не опирается на операторы сравнения, поэтому может достигать $O(n)$ , но универсальность у нее ниже.
## 11.1.2 &nbsp; Идеальный алгоритм сортировки
**Быстрый, выполняющийся на месте, стабильный, адаптивный и универсальный**. Очевидно, что на сегодняшний день не существует алгоритма сортировки, который одновременно обладал бы всеми этими свойствами. Поэтому при выборе алгоритма сортировки нужно исходить из конкретных особенностей данных и требований задачи.
Далее мы последовательно изучим разные алгоритмы сортировки и на основании приведенных выше критериев разберем их преимущества и недостатки.
ru/docs/chapter_sorting/summary.md
+53
View File
@@ -0,0 +1,53 @@
---
comments: true
---
# 11.11 &nbsp; Резюме
### 1. &nbsp; Ключевые выводы
- Сортировка пузырьком выполняет сортировку за счет обмена соседних элементов. Если добавить флаг для досрочного выхода, лучшую временную сложность пузырьковой сортировки можно оптимизировать до $O(n)$ .
- Сортировка вставками на каждом раунде вставляет элемент из неотсортированного диапазона в правильную позицию внутри отсортированного диапазона. Хотя ее временная сложность равна $O(n^2)$ , она очень популярна для задач сортировки небольших массивов, поскольку число элементарных операций у нее сравнительно невелико.
- Быстрая сортировка основана на операции разделения с опорным элементом. При неудачном выборе опорного элемента на каждом раунде ее временная сложность может деградировать до $O(n^2)$ . Использование медианы трех элементов или случайного опорного элемента уменьшает вероятность этой деградации. Если всегда рекурсивно обрабатывать более короткий поддиапазон первым, можно эффективно уменьшить глубину рекурсии и оптимизировать пространственную сложность до $O(\log n)$ .
- Сортировка слиянием включает этапы разделения и слияния и служит типичным проявлением стратегии "разделяй и властвуй". Для сортировки массива ей требуется вспомогательный массив, поэтому пространственная сложность равна $O(n)$ ; однако при сортировке связного списка пространственную сложность можно оптимизировать до $O(1)$ .
- Блочная сортировка включает три этапа: распределение данных по блокам, сортировку внутри блоков и объединение результатов. Она тоже отражает стратегию "разделяй и властвуй" и подходит для очень больших объемов данных. Ключ к эффективности блочной сортировки - равномерное распределение данных.
- Сортировка подсчетом является частным случаем блочной сортировки; она реализует сортировку через подсчет числа вхождений данных. Сортировка подсчетом подходит для случаев, когда объем данных велик, но диапазон значений ограничен, и при этом данные можно преобразовать в положительные целые числа.
- Поразрядная сортировка выполняет сортировку данных путем последовательной сортировки по каждому разряду и требует, чтобы данные можно было представить в виде чисел фиксированной разрядности.
- В общем случае нам хотелось бы найти алгоритм сортировки, который одновременно обладал бы высокой эффективностью, стабильностью, свойством выполнения на месте и адаптивностью. Но, как и в других разделах алгоритмов и структур данных, не существует одного алгоритма сортировки, способного удовлетворить всем этим требованиям одновременно. На практике приходится выбирать подходящий алгоритм в зависимости от свойств данных.
- На рисунке 11-19 сравниваются эффективность, стабильность, выполнение на месте и адаптивность основных алгоритмов сортировки.
![Сравнение алгоритмов сортировки](summary.assets/sorting_algorithms_comparison.png){ class="animation-figure" }
<p align="center"> Рисунок 11-19 &nbsp; Сравнение алгоритмов сортировки </p>
### 2. &nbsp; Вопросы и ответы
**В**: В каких случаях стабильность алгоритма сортировки является обязательной?
В реальных задачах нам может понадобиться сортировать объекты по некоторому атрибуту. Например, у студентов есть два атрибута: имя и рост. Мы хотим выполнить многоуровневую сортировку: сначала отсортировать по имени и получить `(A, 180) (B, 185) (C, 170) (D, 170)` , а затем отсортировать по росту. Если используемый алгоритм сортировки нестабилен, то мы можем получить `(D, 170) (C, 170) (A, 180) (B, 185)` .
Нетрудно увидеть, что в этом случае студенты D и C поменялись местами, порядок по имени разрушился, а именно этого мы и не хотим.
**В**: Можно ли поменять местами порядок "поиска справа налево" и "поиска слева направо" в разделении с опорным элементом?
Нет. Если в качестве опорного элемента выбирается самый левый элемент, необходимо сначала выполнять "поиск справа налево", а уже затем - "поиск слева направо". Этот вывод кажется немного неочевидным, поэтому разберем его подробнее.
Последний шаг `partition()` - это обмен `nums[left]` и `nums[i]` . После обмена все элементы слева от опорного должны быть `<=` опорного, **а значит, перед этим обменом должно выполняться условие `nums[left] >= nums[i]`**. Если сначала выполнять "поиск слева направо", то в случае, когда не удается найти элемент больше опорного, **цикл завершится в состоянии `i == j` , и при этом может оказаться, что `nums[j] == nums[i] > nums[left]`**. Иными словами, на последнем шаге обмена элемент, больший опорного, будет помещен в начало массива, из-за чего разделение завершится неверно.
Например, для массива `[0, 0, 0, 0, 1]` , если сначала выполнять "поиск слева направо", после разделения получится `[1, 0, 0, 0, 0]` , а это неправильный результат.
Если же выбрать `nums[right]` в качестве опорного элемента, то ситуация станет противоположной, и тогда сначала нужно выполнять "поиск слева направо".
**В**: Почему при оптимизации глубины рекурсии в быстрой сортировке выбор короткого массива гарантирует, что глубина рекурсии не превысит $\log n$ ?
Глубина рекурсии - это число текущих рекурсивных вызовов, которые еще не завершились. На каждом раунде разделения исходный массив разбивается на два подмассива. После оптимизации глубины рекурсии длина подмассива, в который мы продолжаем рекурсивный спуск, не превышает половины длины исходного массива. Если рассматривать худший случай, когда длина каждый раз становится ровно вдвое меньше, итоговая глубина рекурсии и будет равна $\log n$ .
В исходной версии быстрой сортировки может происходить последовательный рекурсивный вызов для более длинных массивов; в худшем случае это будут длины $n$ , $n - 1$ , $\dots$ , $2$ , $1$ , а глубина рекурсии окажется равной $n$ . Оптимизация глубины рекурсии как раз и позволяет избежать такого сценария.
**В**: Если все элементы массива равны, будет ли временная сложность быстрой сортировки равна $O(n^2)$ ? Как справиться с таким вырождением?
Да. Для этого случая можно рассмотреть разделение массива на три части: элементы меньше опорного, равные опорному и большие опорного. Рекурсию нужно продолжать только для частей меньше и больше опорного. При таком подходе массив, целиком состоящий из одинаковых элементов, будет отсортирован всего за один раунд разделения.
**В**: Почему худшая временная сложность блочной сортировки равна $O(n^2)$ ?
В худшем случае все элементы попадут в один и тот же блок. Если затем сортировать этот блок алгоритмом со сложностью $O(n^2)$ , то общая временная сложность тоже станет $O(n^2)$ .