Вопрос с собеседования · Основы

Как работает сортировка слиянием?

JuniorСортировки
Ещё спрашивают так:
  • Почему сортировка слиянием всегда O(n log n)?
  • Как слить два отсортированных массива?
  • Где применяют внешнюю сортировку?
Коротко

Делим массив пополам, рекурсивно сортируем половины и сливаем их, каждый раз беря меньший из двух первых элементов.

  • Всегда O(n log n): log n уровней деления, на каждом O(n) работы слияния
  • Устойчива, но требует O(n) дополнительной памяти

А ещё Слияние читает данные последовательно — поэтому подходит для внешней сортировки и связных списков

Попробуйте сами

Сортировки по шагам: пузырёк, вставки, выбор, слияние, быстрая, пирамидальная

Подробно

Алгоритм:

  1. если в массиве 0 или 1 элемент — он отсортирован;
  2. разделить массив на две половины;
  3. рекурсивно отсортировать каждую;
  4. слить две отсортированные половины в одну.

Слияние — два указателя на начала половин. На каждом шаге берём меньший из двух текущих элементов и переносим в результат; когда одна половина кончилась, дописываем остаток другой. Это O(n) для двух половин суммарной длины n. Если при равенстве брать элемент из левой половины, сохраняется исходный порядок равных — сортировка устойчива.

Сложность. Глубина деления — log₂ n уровней, на каждом уровне сливается ровно n элементов. Итого O(n log n) в любом случае — нет худшего случая, как у быстрой сортировки. Цена — O(n) дополнительной памяти под временный массив.

Где особенно хороша:

  • внешняя сортировка — данные не помещаются в память: сортируем куски, пишем на диск и сливаем потоками (так работают базы данных и сортировка больших файлов);
  • связные списки — слияние не требует произвольного доступа и дополнительной памяти под массив;
  • там, где нужна устойчивость — основа Timsort.

Пример

def merge_sort(a):
    if len(a) <= 1:
        return a
    mid = len(a) // 2
    left, right = merge_sort(a[:mid]), merge_sort(a[mid:])
    result, i, j = [], 0, 0
    while i < len(left) and j < len(right):
        if left[i] <= right[j]:          # <= сохраняет устойчивость
            result.append(left[i]); i += 1
        else:
            result.append(right[j]); j += 1
    return result + left[i:] + right[j:]

Что хотят услышать

  • Схема: деление, рекурсия, слияние.
  • Как работает слияние двумя указателями.
  • Почему O(n log n) всегда и цена O(n) памяти.
  • Устойчивость и внешняя сортировка — плюс.

Частые ошибки

  • Забыть дописать остаток одной из половин при слиянии.
  • Нарушить устойчивость, используя строгое сравнение <.

Проверьте себя

Один верный вариант. Подумайте, потом откройте ответ.

Показать варианты и ответ
  • ✗Делит массив вокруг опорного элемента и сортирует части на месте без дополнительной памяти; худший случай O(n²), сортировка неустойчива
  • ✗Её худший случай O(n²)
  • ✓Делит массив пополам, сортирует половины и сливает; всегда O(n log n), устойчива, требует O(n) памяти
  • ✗Сортировка слиянием неустойчива

Что спросят дальше

Связанные вопросы

Партнёр платформы

Разбор собеседования с sotto

После собеседования sotto разбирает разговор: оценка, каждый вопрос — хорошо, частично или слабо, чего не хватило в ответе и над чем поработать к следующему разу. Первые 30 минут бесплатно.

Разбор собеседования