Быстрая сортировка
Быстрая сортировка (англ. 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)
Улучшения
В случае повторяющихся неудачных разбиений опорным элементом, глубина рекурсии может достичь , а время работы алгоритма . Существуют различные способы разбиения массива, направленные против худшего случая:
- При выборе опорного элемента из данного диапазона случайным образом худший случай становится очень маловероятным и ожидаемое время выполнения алгоритма сортировки — .
- Выбирать опорным элементом средний из трех (первого, среднего и последнего элементов).
- Разбивать массив не на две, а на три части.
Оптимизация глубины рекурсии до O(logn) в худшем случае
Во избежание достижения опасной глубины рекурсии в худшем случае (или при приближении к нему) возможна модификация алгоритма, устраняющая одну ветвь рекурсии: вместо того, чтобы после разделения массива вызывать рекурсивно процедуру разделения для обоих найденных подмассивов, рекурсивный вызов делается только для меньшего подмассива, а больший обрабатывается в цикле в пределах этого же вызова процедуры. С точки зрения эффективности в среднем случае разницы практически нет: накладные расходы на дополнительный рекурсивный вызов и на организацию сравнения длин подмассивов и цикла — примерно одного порядка. Зато глубина рекурсии ни при каких обстоятельствах не превысит , а в худшем случае вырожденного разделения она вообще будет не более 2 — вся обработка пройдёт в цикле первого уровня рекурсии.
Источники информации
- Википедия — быстрая сортировка
- Wikipedia — Quicksort
- Т. Кормен, Ч. Лейзерсон, Р. Ривест: Алгоритмы: построение и анализ глава 7
