11.2 Сортировка выбором¶

Сортировка выбором (selection sort) работает очень просто: запускается цикл, и на каждом шаге из неотсортированного диапазона выбирается минимальный элемент, после чего он переносится в конец уже отсортированного диапазона.

Пусть длина массива равна \(n\) ; тогда процесс сортировки выбором выглядит так, как показано на рисунке 11-2.

В начальном состоянии все элементы не отсортированы, то есть неотсортированный диапазон индексов равен \([0, n-1]\) .
Выбрать минимальный элемент из диапазона \([0, n-1]\) и поменять его местами с элементом в позиции \(0\) . После этого первые 1 элементов массива отсортированы.
Выбрать минимальный элемент из диапазона \([1, n-1]\) и поменять его местами с элементом в позиции \(1\) . После этого первые 2 элементов массива отсортированы.
Продолжать по аналогии. После \(n - 1\) раундов выбора и обмена первые \(n - 1\) элементов массива будут отсортированы.
Оставшийся элемент обязательно является максимальным, сортировать его не нужно, поэтому массив считается отсортированным.

Рисунок 11-2 Шаги сортировки выбором

В коде мы используем \(k\) для записи минимального элемента в пределах неотсортированного диапазона:

PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby

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]

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]);
    }
}

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;
    }
}

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]);
    }
}

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]

    }
}

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)
    }
}

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]];
    }
}

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]];
    }
}

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;
  }
}

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);
    }
}

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;
    }
}

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
    }
}

selection_sort.rb

### Сортировка выбором ###
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

Визуализация кода

Во весь экран >

11.2.1 Характеристики алгоритма¶

Временная сложность равна \(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] может быть переставлен вправо от другого равного ему элемента, из-за чего их относительный порядок изменится.

Пример нестабильности сортировки выбором

Рисунок 11-3 Пример нестабильности сортировки выбором

11.2 Сортировка выбором¶

11.2.1 Характеристики алгоритма¶

Оставляйте свои идеи, вопросы и предложения в комментариях