Timsort

Timsort

Timsort — гибридный алгоритм сортировки, сочетающий сортировку вставками и сортировку слиянием.

Данный алгоритм был изобретен в 2002 году Тимом Петерсом(в честь него и назван) и основывается на том, что в реальном мире сортируемые массивы данных часто содержат в себе упорядоченные подмассивы. На таким данных алгоритм Тима Петерса существенно быстрее многих других алгоритмов сортировки. В настоящее время Timsort является стандартной сортировкой в Python, OpenJDK 7 и реализован в Android JDK 1.5.

Основная идея алгоритма

Алгоритм Timsort состоит из нескольких шагов:

• Шаг №1: по специальному алгоритму входной массив разделяется на подмассивы.

• Шаг №2: каждый подмассив сортируется сортировкой вставками или сортировкой выбором.

• Шаг №3: отсортированные подмассивы собираются в единый массив с помощью модифицированной сортировки слиянием.

Алгоритм

Используемые понятия и комментарии

• [math]n[/math] — размер входного массива.

• [math]run[/math] — некоторый подмассив во входном массиве, который обязан быть упорядоченным одним из двух способов:
  • строго по убыванию [math] a_{i} \gt a_{i + 1} \gt ... [/math].
  • нестрого по возрастанию [math] a_{i} \le a_{i + 1} \le ... [/math].

• [math]minrun[/math] — минимальный размер подмассива, описанного в предыдущем пункте.

Шаг №1. Вычисление minrun

Число [math]minrun[/math] определяется на основе [math] n [/math], исходя из принципов:

• Не должно быть слишком большим, поскольку к подмассиву размера [math] minrun [/math] будет в дальнейшем применена сортировка вставками (эффективна только на небольших массивах).

• Оно не должно быть слишком маленьким, так как чем меньше подмассив — тем больше итераций слияния подмассивов придётся выполнить на последнем шаге алгоритма. Оптимальная величина для [math] n / minrun [/math] — степень двойки. Это требование обусловлено тем, что алгоритм слияния подмассивов наиболее эффективно работает на подмассивах примерно равного размера.

• Согласно авторским экспериментам:
  • При [math] minrun \gt 256 [/math] нарушается пункт [math]1[/math].
  • При [math] minrun \lt 8 [/math] нарушается пункт [math]2[/math].
  • Наиболее эффективные значения [math] minrun [/math] из диапозона [math] (32; 65) [/math].
  • Исключение — если [math] n \lt 64 [/math], тогда [math] n = minrun [/math] и Timsort превращается в сортировку вставками.

Таким образом, алгоритм расчета [math] minrun [/math] не так уж сложен: берем старшие 6 бит числа [math] n [/math] и добавляем единицу, если в оставшихся младших битах есть хотя бы один ненулевой.

 int GetMinrun(int n) {
     int flag = 0;           /* станет 1 если среди сдвинутых битов есть хотя бы 1 ненулевой */
     while (n >= 64) {
         flag |= n & 1;
         n >>= 1;
     }
     return n + flag;
 }

Шаг №2. Алгоритм разбиения на подмассивы и их сортировка

На данном этапе у нас есть входной массив, его размер [math]n[/math] и вычисленное число [math]minrun[/math]. Обратим внимание, что если данные изначального массива достаточно близки к случайным, то размер упорядоченных подмассивов близок к [math]minrun[/math],. Но если в изначальных данных были упорядоченные диапазоны, то упорядоченные подмассивы могут иметь размер, превышающий [math]minrun[/math].

• Начало.
• Указатель текущего элемента ставится в начало входного массива.
• Начиная с текущего элемента, идет поиск во входном массиве упорядоченного подмассива [math]run[/math]. По определению, в [math]run[/math] однозначно войдет текущий элемент и следующий за ним. Если получившийся подмассив упорядочен по убыванию — элементы переставляются так, чтобы они шли по возрастанию.
• Если размер текущего [math]run[/math] меньше [math]minrun[/math], тогда выбираются следующие за найденным подмассивом [math]run[/math] элементы в количестве [math] minrun - size(run) [/math]. Таким образом, на выходе будет получен подмассив размером большим или равный [math]minrun[/math], часть которого (в лучшем случае — он весь) упорядочена.
• К данному подмассиву применяем сортировка вставками. Так как размер подмассива невелик и часть его уже упорядочена — сортировка работает эффективно.
• Указатель текущего элемента ставится на следующий за подмассивом элемент.
• Если конец входного массива не достигнут — переход к пункту 2
• Конец.

Шаг №3. Слияние

Нужно объединить полученные подмассивы для получения результирующего упорядоченного массива. Для достижения эффективности, объединение должно объединять подмассивы примерно равного размера и cохранять стабильность алгоритма (не делать бессмысленных перестановок).

• Начало.
• Создается пустой стек пар [math] \lt [/math]индекс начала подмассива[math] \gt [/math] — [math] \lt [/math]размер подмассива[math] \gt [/math].
• Берется первый упорядоченный подмассив.
• Добавляется в стек пара данных [math] \lt [/math]индекс начала текущего подмассива[math] \gt [/math] — [math] \lt [/math]его размер[math] \gt [/math].
• Пусть [math]X,Y,Z [/math] — длины верхних трех интервалов, которые лежат в стеке. Причем [math]X[/math] — это последний элемент стека.
• Повторяем пока выражение ([math]Z \gt X + Y[/math] && [math]Y \gt X[/math]) не станет истинным
  • Если размер стека не меньше 3 и [math]Z \leqslant X + Y[/math] — сливаем [math]Y[/math] c [math]min(X,Z)[/math].
  • Иначе Если [math]Y \leqslant X [/math] — сливаем [math]X[/math] c [math]Y[/math].
  • Возвращаемся в п.6.
• Конец

Основная цель этой процедуры — сохранение баланса. Изменения будут выглядеть как на картинке, а значит и размеры подмассивов в стеке эффективны для дальнейшей сортировки слиянием.

Описание процедуры слияния

• Создается временный массив в размере меньшего из сливаемых подмассивов.

• Меньший из подмассивов копируется во временный массив, но надо учесть, что если меньший подмассив [math]-[/math] правый, то ответ (результат сливания) формируется справа налево. Дабы избежать данной путаницы, лучше копировать всегда левый подмассив во временный. На скорости это практически не отразится.

• Ставятся указатели текущей позиции на первые элементы большего и временного массива.

• На каждом шаге рассматривается значение текущих элементов в большем и временном массивах, берется меньший из них, копируется в новый отсортированный массив. Указатель текущего элемента перемещается в массиве, из которого был взят элемент.

• Предыдущий пункт повторяется, пока один из массивов не закончится.

• Все элементы оставшегося массива добавляются в конец нового массива.

Пример

Возьмем [math]n = 356[/math]. При таком [math]n[/math] [math]minrun[/math] оказался равным 45. Ниже представлена работа алгоритма. Числа с закрывающей скобкой показывают номера шагов, на которых произошло сливание нижестоящих подмассивов.

Модификация процедуры слияния подмассивов (Galloping Mode)

Рассмотрим процедуру слияния двух массивов:

[math]A = {1, 2, 3, ..., 9999, 10000}[/math]

[math]B = {20000, 20001, 20002, ..., 29999, 30000}[/math]

Вышеуказанная процедура для них сработает, но каждый раз на её четвёртом пункте нужно будет выполнить одно сравнение и одно копирование. В итоге 10000 сравнений и 10000 копирований. Алгоритм Timsort предлагает в этом месте модификацию, которая получила называет «галоп». Алгоритм следующий:

• Начинается процедура слияния.

• На каждой операции копирования элемента из временного или большего подмассива в результирующий запоминается, из какого именно подмассива был элемент.

• Если уже некоторое количество элементов (в данной реализации алгоритма это число равно 7) было взято из одного и того же массива — предполагается, что и дальше придётся брать данные из него. Чтобы подтвердить эту идею, алгоритм переходит в режим «галопа», то есть перемещается по массиву-претенденту на поставку следующей большой порции данных бинарным поиском (массив упорядочен) текущего элемента из второго соединяемого массива.

• В момент, когда данные из текущего массива-поставщика больше не подходят (или был достигнут конец массива), данные копируются целиком.

Для вышеописанных массивов [math] A, B [/math] алгоритм выглядит следующим образом: Первые 7 итераций сравниваются числа [math]1, 2, 3, 4, 5, 6, 7[/math] из массива [math]A[/math] с числом [math]20000[/math], так как [math]20000[/math] больше, то элементы массива [math]A[/math] копируются в результирующий. Начиная со следующей итерации алгоритм переходит в режим «галопа»: сравнивает с числом [math]20000[/math] последовательно элементы [math]8, 10, 14, 22, 38, 7+2^{i - 1}, ..., 10000 [/math] массива [math]A[/math]. ([math] \thicksim\log_{2}(n)[/math] сравнений). После того как конец массива [math]A[/math] достигнут и известно, что он весь меньше [math]B[/math], нужные данные из массива [math]A[/math] копируются в результирующий.

Доказательство времени работы алгоритма

Не сложно заметить, что чем меньше массивов, тем меньше произойдёт операций слияния, но чем их длины больше, тем дольше эти слияния будут происходить. На малом количестве длинных массивов хорошо помогает вышеописанный метод Galloping Mode. Хоть он и не даёт асимптотического выигрыша, но уменьшает константу. Пусть [math]k[/math] — число кусков, на которые разбился наш исходный массив, очевидно [math] k [/math] = [math] \ulcorner \frac{n}{minrun} \urcorner [/math]. Главный факт, который нам понадобится для доказательства нужной оценки времени работы в [math]О(nlog(n))[/math] — это то, что сливаемые массивы всегда имеют примерно одинаковую длинну. Можно сказать больше — пока [math]k \gt 3[/math] сливаемые подмассивы будут именно одинаковой длинны (данный факт хорошо виден на примере). Безусловно, после разбения массива на блоки длинной [math]minrun[/math] последний блок может быть отличен от данного значения практически в 2 раза, но эти 20-30 элементов разницы при [math]n[/math] порядка [math]10^6[/math] практически не повлияют на время работы.

Мы выяснили, что при слиянии, длинна образовавшегося слитого массива увеличивается [math]\approx[/math] 2 раза. Таким образом получаем, что каждый подмассив [math]run_i[/math] может участвовать в не более [math]O(log(n))[/math] операций слияния, а значит и каждый элемент будет задействован в сравниниях не более [math]O(log(n))[/math] раз. Элементов [math]n[/math], откуда получаем оценку в [math]O(nlog(n))[/math].

Также нужно сказать про сортировку вставками, которая используется для сортировки подмассивов [math]run_i[/math]: в нашем случае, алгоритм работает за [math]O(minrun + inv)[/math], где [math]inv[/math] — число обменов элементов входного массива, равное числу инверсий. C учетом значения [math]k[/math], получим, что сортировка всех блоков может занять [math]O(minrun + inv) * k = O(minrun + inv) * [/math][math]\ulcorner \frac{n}{minrun} \urcorner [/math]. Что в худшем случае ([math]inv[/math] = [math] \frac{minrun*(minrun - 1)}{2} [/math]) может занимать [math]O(n + n*minrun) [/math] времени. Откуда видно, что константа [math]minrun[/math] играет не малое значение: при большом [math]minrun[/math] слияний будет меньше, а сортировки вставками будут выполняться долго. Причём эти функцию растут с разной скоростью, поэтому видимо и был выбран вот такой оптимальный диапазон — от 32 до 64.

Источники

• Peter McIlroy "Optimistic Sorting and Information Theoretic Complexity", Proceedings of the Fourth Annual ACM-SIAM Symposium on Discrete Algorithms, ISBN 0-89871-313-7, Chapter 53, pp 467-474, January 1993.

• Magnus Lie Hetland Python Algorithms: Mastering Basic Algorithms in the Python Language. — Apress, 2010. — 336 с.

• Wikipedia - Timsort

• Habrahabr - Алгоритм сортировки Timsort