Быстрая сортировка
Быстрая сортировка (англ. quick sort, сортировка Хоара) — один из самых известных и широко используемых алгоритмов сортировки. Среднее время работы , что является асимптотически оптимальным временем работы для алгоритма, основанного на сравнении. Хотя время работы алгоритма для массива из элементов в худшем случае может составить , на практике этот алгоритм является одним из самых быстрых.
Алгоритм
- Массив разбивается на два (возможно пустых) подмассива и , таких, что каждый элемент меньше или равен , который в свою очередь, не превышает любой элемент подмассива . Индекс вычисляется в ходе процедуры разбиения.
- Подмассивы и сортируются с помощью рекурсивного вызова процедуры быстрой сортировки.
- Поскольку подмассивы сортируются на месте, для их объединения не требуются никакие действия: весь массив оказывается отсортированным.
Псевдокод
void quicksort(A: int[n], int l, int r):
if l < r
q = partition(A, l, r)
quicksort(A, l, q - 1)
quicksort(A, q + 1, r)
Для сортировки всего массива необходимо выполнить процедуру .
Разбиение массива
Основной шаг алгоритма сортировки — процедура , которая переставляет элементы массива нужным образом:
int partition(a: int[n], int l, int r):
v = a[r]
i = l
j = r - 1
while true {
while (a[i] < v)
i = i + 1
while (a[j] > v)
j = j - 1
if (j == l)
break
if (i j)
break
swap(a[i], a[j])
}
swap(a[i], a[r])
return i
Асимптотика
Худшее время работы
Предположим, что мы разбиваем массив так, что одна часть содержит элементов, а вторая — . Поскольку процедура разбиения занимает время , для времени работы получаем соотношение:
.
Мы видим, что при максимально несбалансированном разбиении время работы составляет . В частности, это происходит, если массив изначально отсортирован.
Способ построить массив с максимальным количеством сравнений при выборе среднего элемента в качестве опорного
В некоторых алгоритмах быстрой сортировки в качестве опорного выбирается элемент, который стоит в середине рассматриваемого массива. Рассмотрим массив, на котором быстрая сортировка с выбором среднего элемента в качестве опорного сделает сравнений. Очевидно, что это будет достигаться при худшем случае (когда при каждом разбиении в одном массиве будет оказываться , а в другом элемент).
Заполним сначала массив длины элементами от до , затем применим следующий алгоритм (нумерация с нуля):
function antiQsort(A: int[n]):
for i = 0 to n - 1
swap(A[i], A[i / 2])
Тогда на каждом шаге в качестве среднего элемента будет ставиться самый крупный элемент.
При выполнении делается сравнений из-за того, что с помощью индексов и мы проходим в лучшем случае элементов (если функция прекращает свою работу, как только индексы встречаются), в худшем случае элементов (если оба индекса полностью проходят массив). При каждом изменении индекса делается сравнение, значит, процедура делает сравнений с точностью до константы.
Рассмотрим, какой элемент будет выбираться опорным на каждом шаге. на каждом шаге меняет местами последний и центральный элементы, поэтому в центре оказывается самый крупный элемент. А делает абсолютно симметричные этой процедуре операции, но в другую сторону: меняет местами центральный элемент с последним, так что самый крупный элемент становится последним, а затем выполняет на массиве длины на один меньшей ту же операцию. Получается, что опорным всегда будет выбираться самый крупный элемент, так как на массиве любой длины будет выполнять операции, обратные . Фактически, — это , запущенная в другую сторону. Также стоит отметить, что процедура разбиения будет делать на каждом шаге только одну смену элементов местами. Сначала дойдет до середины массива, до опорного элемента, останется равным индексу последнего элемента. Затем произойдет и снова начнет увеличиваться, пока не дойдет до последнего элемента, опять не изменит свою позицию. Потом произойдет выход из .
Разбиение массива будет произведено раз, потому что разбиение производится на массивы длины и из-за того, что на каждом шаге разбиения в качестве опорного будет выбираться самый крупный элемент (оценка на худшее время работы доказана выше). Следовательно, на массиве, который строится описанным выше способом, выполняется и сравнений для каждого выполнения . Тогда быстрая сортировка выполнит сравнений для массива, построенного таким способом.
Способ построить массив с максимальным количеством сравнений при детерминированном выборе опорного элемента
Рассмотрим алгоритм построения массива, на котором быстрая сортировка с детерминированным выбором опорного элемента будет делать максимальное (в данном случае — ) количество сравнений. Такое число сравнений достигается при разбиении на массивы длиной и на каждой итерации. Создадим массив длины , заполненный элементами типа . Такой элемент хранит пару значений , где — элемент массива, а — индекс. Изначально элемент имеет вид .
Далее, запустим для данного массива алгоритм быстрой сортировки. Сравниваем два элемента типа по их значениям . На каждом шаге будем выполнять следующие действия: при обращении к -ому элементу в качестве опорного на шаге под номером , присвоим для элемента . Затем выполним шаг сортировки. После завершения работы алгоритма быстрой сортировки, дополнительно отсортируем получившиеся элементы по значениям . Искомым будет являться массив элементов в соответствующей последовательности.
Пример для , при последовательном выборе опорных элементов .
| Построение массива | |||||||
|---|---|---|---|---|---|---|---|
| Шаг 1.0 | Шаг 1.1 | Шаг 1.2 | Шаг 2.0 | Шаг 2.1 | Шаг 2.2 | Шаг 3.0 | |
| 1 2 3 4 <br\> 0 0 0 0 | 1 2 3 4 <br\> 0 4 0 0 | 1 4 3 2 <br\> 0 0 0 4 | 1 4 3 2 <br\> 0 0 0 4 | 1 4 3 2 <br\> 0 3 0 4 | 1 3 4 2 <br\> 0 0 3 4 | 1 3 4 2 <br\> 0 0 3 4 | |
| Шаг 3.1 | Шаг 3.2 | Шаг 4.0 | Шаг 4.1 | Шаг 4.2 | Результат | ||
| 1 3 4 2 <br\> 2 0 3 4 | 3 1 4 2 <br\> 0 2 3 4 | 3 1 4 2 <br\> 0 2 3 4 | 3 1 4 2 <br\> 1 2 3 4 | 3 1 4 2 <br\> 1 2 3 4 | 1 2 3 4 <br\> 2 4 1 3 | ||
| Итоговый массив | |||||||
|
2 4 1 3 | |||||||
Покажем, почему на данном массиве будет достигаться максимальное время работы быстрой сортировки. На этапе построения мы каждый раз присваивали опорному элементу минимальное значение. Следовательно, при выполнении алгоритм в качестве опорного всегда будет выбирать наибольший элемент массива (выборка будет производится в том же порядке ввиду детерминированности определения опорного элемента). Таким образом, так как каждый раз массив разбивается на две части — большие или равные опорному элементы и меньшие его — на каждом шаге имеем разбиение на массивы длины и , чего мы, собственно, и добивались. При таком выполнении алгоритма происходит разделений на два подмассива, и на каждом разделении выполняется сравнений. Следовательно, на данном массиве быстрая сортировка работает за .
Среднее время работы
| Лемма: |
Время работы алгоритма быстрой сортировки равно . |
| Доказательство: |
|
Пусть Х — полное количество сравнений элементов с опорным за время работы сортировки. Нам необходимо вычислить полное количество сравнений. Переименуем элементы массива как , где наименьший по порядку элемент. Также введем множество . Заметим, что сравнение каждой пары элементов происходит не больше одного раза, так как элемент сравнивается с опорным, а опорный элемент после разбиения больше не будет участвовать в сравнении. Поскольку каждая пара элементов сравнивается не более одного раза, полное количество сравнений выражается как , где если произошло сравнение и и , если сравнения не произошло. Применим к обоим частям равенства операцию вычисления матожидания и воспользовавшись ее линейностью получим сравнивается с Осталось вычислить величину сравнивается с — вероятность того, что сравнивается с . Поскольку предполагается, что все элементы в массиве различны, то при выборе в качестве опорного элемента впоследствии не будут сравниваться никакие и для которых . С другой стороны, если выбран в качестве опорного, то он будет сравниваться с каждым элементом кроме себя самого. Таким образом элементы и сравниваются тогда и только тогда когда первым в множестве опорным элементом был выбран один из них. сравнивается с первым опорным элементом был или первым опорным элементом был первым опорным элементом был |
Mатожидание времени работы быстрой сортировки будет .
Модификации
Нерекурсивная реализация быстрой сортировки
void quicksort(a: int[n], int l, int r):
stack <int> s
s.push(l, r);
while (!s.empty())
l = s.pop()
r = s.pop()
if (r l)
continue
int i = partition(a, l, r);
if (i - 1 > r - i)
s.push(l, i - 1)
s.push(i + 1, r)
else
s.push(i + 1, r)
s.push(l, i - 1)
Улучшенная быстрая сортировка
Выбор медианы из первого, среднего и концевого элементов в качестве разделяющего элемента и отсечение рекурсии меньших подмассивов может привести к существенному повышению эффективности быстрой сортировки. Данная реализация осуществляет разделение по медиане из первого, среднего и концевого элементов массива). Массивы небольшого размера (длиной и меньше) в процессе разделения игнорируются; затем для окончания сортировки используется сортировка вставками.
const int M = 10
void quicksort(a: int[n], int l, int r):
if (r - 1 M)
return
swap(a[(l + r)/2], a[r - 1])
median(a[l], a[r - 1], a[r])
int i = partition(l + 1, r - 1)
quicksort(a, l, i - 1)
quicksort(a, i + 1, r)
void hybridsort(a: int[n], int l, int r):
quicksort(a, l, r)
insertion(a, l, r)
Быстрая сортировка с разделением на три части
Когда в сортируемом файле имеется множество дублированных ключей предыдущие реализации быстрой сортировки можно существенно улучшить. Например массив, который состоит из равных ключей, вовсе не нуждается в дальнейшей сортировке, однако предыдущие реализации продолжают процесс разделения, подвергая обработке все более мелкие подфайлы независимо от того, насколько большим является исходный файл.
В основу программы положено разделение массива на три части: на элементы,меньшие разделяющего элемента (в позиции ), элементы, равные разделяющему элементу (в позиции ), и элементы большие разделяющего элемента (в позиции ). После этого сортировка завершается двумя рекурсивными вызовами.
Просмотр массива начинается слева с целью обнаружить элемент, который не меньше разделяющего элемента, и справа с целью обнаружить элемент, который не больше разделяющего элемента, затем они меняются местами. Если после обмена элемент слева равен разделяющему элементу, он меняется местами с левым крайним элементом массива; то же самое проделывается и справа.
После того как указатели пересекутся, элементы, равные разделяющему элементу и находящиеся на разных концах массива, после операции обмена попадают в свои окончательные позиции. После этого указанные ключи могут быть исключены из подфайлов, для которых выполняются последующие рекурсивные вызовы.
void quicksort(a: int[n], int l, int r):
int k
int v = a[r]
if (r l)
return
int i = l
int j = r - 1
int p = l - 1
int q = r
while true
while (a[i] < v)
i++
while (a[j] > v)
j--
if (i == j)
break
if (i j)
break
swap(a[i], a[j])
if (a[i] == v)
p++
swap(a[p], a[i])
if (a[j] == v)
q--
swap(a[q], a[j])
swap(a[i], a[r])
j = i - 1
i++
for (k = 1 ; k p; k++, j--)
swap(a[k],a[j])
for (k = r-1; k q; k--, i++)
swap(a[k],a[i])
quicksort(a, 1, j)
quicksort(a, i, r)
Источники информации
- Википедия — быстрая сортировка
- Wikipedia — Quicksort
- Т. Кормен, Ч. Лейзерсон, Р. Ривест: Алгоритмы: построение и анализ глава 7
