Перейти к содержанию
Приглашаем вас участвовать в развитии русской версии! Подробнее здесь.

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

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

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

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

<1><2><3><4><5><6><7><8><9><10><11>

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

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

Python C++Java C#Go Swift JS TS Dart Rust C Kotlin Ruby
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 - 1\) раз в первом раунде и \(1\) раз в последнем. Таким образом, число итераций внутреннего цикла по раундам равно \(n - 1\), \(n - 2\), \(\dots\), \(2\), \(1\), а их сумма равна \(\frac{n(n - 1)}{2}\) .
- Пространственная сложность равна \(O(1)\), сортировка выполняется на месте: указатели \(i\) и \(j\) используют константный объем дополнительной памяти.
- Нестабильная сортировка: как показано на рисунке 11-3, элемент `nums[i]` может быть переставлен вправо от другого равного ему элемента, из-за чего их относительный порядок изменится.

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

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