Алгоритмы сортировки

Содержание

Слайд 2

На вход алгоритма подаётся последовательность n элементов Задача На выходе алгоритм

На вход алгоритма подаётся последовательность n элементов

Задача

На выходе алгоритм должен вернуть

перестановку исходной последовательности

чтобы выполнялось следующее соотношение

Слайд 3

Сортировка пузырьком (bubble sort)

Сортировка пузырьком
(bubble sort)

Слайд 4

Пример i = 1 i = 2 i = 3 i = 4

Пример

i = 1

i = 2

i = 3

i = 4

Слайд 5

Алгоритм for i = 1 to n-1 for j = 1

Алгоритм

for i = 1 to n-1
for j = 1 to n-i
if

A[j] > A[j+1] then
temp = A[j]
A[j] = A[j+1]
A[j+1] = temp
Слайд 6

Сложность for i = 1 to n-1 for j = 1

Сложность

for i = 1 to n-1
for j = 1 to n-i
if

A[j] > A[j+1] then
temp = A[j]
A[j] = A[j+1]
A[j+1] = temp

n

Количество операций

=>

Слайд 7

Сортировка вставками (insertion sort)

Сортировка вставками
(insertion sort)

Слайд 8

Пример

Пример

Слайд 9

Алгоритм for j = 2 to n key = A[j] i

Алгоритм

for j = 2 to n
key = A[j]
i

= j – 1
while i > 0 and A[i] > key
A[i+1] = A[i]
i = i – 1
A[i+1] = key
Слайд 10

Сложность n n-1 n-1 n-1 Количество операций for j = 2

Сложность

n
n-1
n-1
n-1

Количество операций

for j = 2 to n
key = A[j]

i = j – 1
while i > 0 and A[i] > key
A[i+1] = A[i]
i = i – 1
A[i+1] = key
Слайд 11

Сложность Лучший случай: массив отсортирован по возрастанию, тогда Худший случай: массив отсортирован по убыванию, тогда

Сложность

Лучший случай: массив отсортирован по возрастанию, тогда

Худший случай: массив отсортирован

по убыванию, тогда
Слайд 12

Сортировка выбором (selection sort)

Сортировка выбором
(selection sort)

Слайд 13

Пример

Пример

Слайд 14

Алгоритм for i = 1 to n-1 do min = i

Алгоритм

for i = 1 to n-1 do
min = i
for j =

i+1 to n do
if A[min] > A[j] then
min = j
if min<>i then
temp = a[i]
a[i] = a[min]
a[min] = temp
Слайд 15

Сложность for i = 1 to n-1 do min = i

Сложность

for i = 1 to n-1 do
min = i
for j =

i+1 to n do
if A[min] > A[j] then
min = j
if min<>i then
temp = a[i]
a[i] = a[min]
a[min] = temp

Количество операций

n
n-1
n-1

=>

Слайд 16

Быстрая сортировка (Хоара) (QuickSort)

Быстрая сортировка (Хоара)
(QuickSort)

Слайд 17

Идея Вход: массив А, индексы l и r, которые определяют подмассив

Идея

Вход: массив А, индексы l и r, которые определяют подмассив для

сортировки A[l...r].
Выход: отсортированный подмассив A[l...r].

Разбить массив А на 2 части: A[l...q-1] (где все элементы <= A[q]) и A[q+1...r] (где все элементы > A[q]). Элемент X=A[q] - опорный.
Рекурсивное решение задачи для A[l...q-1] и A[q+1...r].

Слайд 18

Алгоритм QuickSort(A,l,r) If l q = Partition(A,l,r) QuickSort(A,l,q-1) QuickSort(A, q+1,r) Partition(A,l,r)

Алгоритм

QuickSort(A,l,r)
If lq = Partition(A,l,r)
QuickSort(A,l,q-1)
QuickSort(A, q+1,r)

Partition(A,l,r)
X = A[r]
i = l -

1
for j = l to r-1
if A[j]<=X then
i = i + 1
A[i] <--> A[j]
A[r] <--> A[i+1]
return i+1
Слайд 19

Алгоритм (случайный выбор опорного элемента) RandomQuickSort(A,l,r) If l q = RandomPartition(A,l,r)

Алгоритм (случайный выбор опорного элемента)

RandomQuickSort(A,l,r)
If lq = RandomPartition(A,l,r)
RandomQuickSort(A,l,q-1)
RandomQuickSort(A, q+1,r)

RandomPartition(A,l,r)
i=random(l,r)
A[i] <-->

A[r]
Partition(A,l,r)
Слайд 20

Процедура разбиения X = A[r] - опорный элемент (разделитель) A[l...i] A[i+1...j-1]

Процедура разбиения

X = A[r] - опорный элемент (разделитель)
A[l...i] <= X
A[i+1...j-1] >X
A[j...r-1]

- элементы, которые еще не рассмотрены

Сложность T(n) = O(n)

Слайд 21

A[j]=2 i=i+1, j=j+1 A[j]=8 > X=4 => j=j+1 A[j]=7 > X=4

A[j]=2 < X=4 => i=i+1, j=j+1

A[j]=8 > X=4 => j=j+1

A[j]=7 >

X=4 => j=j+1

A[j]=1 < X=4 => i=i+1, j=j+1

A[j]=3 < X=4 => i=i+1, j=j+1

A[j]=5 > X=4 => j=j+1

A[j]=6 > X=4 => j=j+1

A[r] <--> A[i+1]

Слайд 22

Сложность Лучший случай. В наиболее сбалансированном варианте при каждой операции разделения

Сложность

Лучший случай. В наиболее сбалансированном варианте при каждой операции разделения массив

делится на две почти одинаковые части. В результате общая сложность алгоритма O(n*log2n).

Средний случай. В среднем глубина рекурсии не превысит 2log3/4n, что равно O(logn). А поскольку на каждом уровне рекурсии по-прежнему выполняется не более O(n) операций, средняя сложность составит O(n*logn).

Худший случай. В самом несбалансированном варианте (в качестве опорного выбран максимальный или минимальный элемент) каждое разделение даёт два подмассива размерами 1 и n-1. Т.о. сложность O(n2).

Слайд 23

Cортировка слиянием (merge sort)

Cортировка слиянием
(merge sort)

Слайд 24

Идея Вход: массив А, индексы l и r, которые определяют подмассив

Идея

Вход: массив А, индексы l и r, которые определяют подмассив для

сортировки A[l...r].
Выход: отсортированный подмассив A[l...r].

Сортируемый массив разбивается на две части примерно одинакового размера
Каждая из получившихся частей сортируется отдельно, например — тем же самым алгоритмом
Два упорядочённых массива половинного размера сливаются в один.

Слайд 25

Пример

Пример

Слайд 26

Алгоритм MergeSort MergeSort(A,l,r) If l q = [(l + r)/2] MergeSort(A,l,q)

Алгоритм MergeSort

MergeSort(A,l,r)
If lq = [(l + r)/2]
MergeSort(A,l,q)
MergeSort(A,q+1,r)
Merge(A,l,q,r)

Сложность алгоритма
T(n) =

O(n * log n)
V(n) = O(n)