Лекция 2: Абстрактные типы данных. Алгоритмы...

Лекция 2 Абстрактные типы данных.

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

Курносов Михаил Георгиевич

к.т.н. доцент Кафедры вычислительных систем Сибирский государственный университет

телекоммуникаций и информатики

http://mkurnosov.net/teaching

Контроль

2

1. Что такое вычислительная сложность алгоритма

(computational complexity)?

2. T(n) = 3n3 + 2n2, O(3n3 + 2n2) = …. ?

3. T(n) = n + logn, O(n + logn) = …. ?

4. T(n) = nlogn + n2, O(nlogn + n2 ) = …. ?

5. T(n) = 2n + n6 – 1000n3, O(2n + n6 – 1000n3) = …. ?

6. T(n) = n6 + n!, O(n6 + n!) = …. ?

7. Какой асимтотической вычислительной сложностью обладает

алгоритм сортировки методом “пузырька”?

8. Какой асимтотической вычислительной сложностью обладает

алгоритм вычисления факториала числа?

Абстрактные типы данных

3

Абстрактный тип данных (АТД, Abstract Data Type) –это тип данных, который предоставляет набор функцийдля работы с его элементами

Клиентские программы не имеют доступа к внутренней реализации типа данных (реализация скрыта – инкапсулирована)

Тип данных переменной (Data Type) –множество значений, которые она может принимать(int, char, double, float)

Абстрактный тип данных “множество” (Set)

4

Набор операций определенных над элементами абстрактного типа данных “множество” (Set):

MakeNull(a) – делает множество a пустым

Size(a) – возвращает количество элементов во множестве a(мощность множества)

Union(a, b, c) – объединяет множеств a и b в множество с

Intersect(a, b, c) – строит пересечение множеств a и b, результат помещается в множество с

Minus(a, b, c)

Add(a, x) – добавляет элемент x к множеству a

Find(a, x) – определяет принадлежит ли элемент xмножеству a

Операция Описание Вычислительнаясложность

Сложность по памяти

Get(a, i) Возвращает i-й

элемент массива aO(1) O(1)

Set(a, i, x) Присваивает i-у

элементу массива aзначение x

O(1) O(1)

Size(a) Возвращает количество элементов в массиве a

O(1) O(1)

Sort(a)Упорядочивает

элементы массива апо не убыванию

O(n2), O(nlogn), O(n + r)

O(1), O(logn),

O(n), O(n + r)

Search(a, x)Отыскивает позицию

элемента x в массиве aO(n), O(logn)

Абстрактный тип данных массив (Array)

5

Набор операций определенных над элементами абстрактного типа данных массив (Array):

#define NELEMS 1024

typedef int elem_t;

elem_t array_get(elem_t *a, int i){

return a[i];}

void array_set(elem_t *a, int i, elem_t x){

a[i] = x;}

int array_size(elem_t *a){

return NELEMS;}

Реализация АТД массив (Array)

6

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

7

Внутренние методы сортировки (Internal sort) –сортируемые элементы полностью размещеныв оперативной памяти компьютера

Внешняя сортировка (External sort) – элементы размещены на внешней памяти (жесткий диск, USB-флеш)

Алгоритм сортировки не использующий дополнительной памяти (кроме сортируемого массива) называется алгоритмом сортировки на месте (In place)

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

8

Алгоритм сортировки не меняющий порядок следования равных элементов называется устойчивым (stable)

(Жираф, 800), (Слон, 1500), (Лиса, 40), (Волк, 90), (Кит, 3000), (Барсук, 40)

Вариант сортировки 1:(Барсук, 40), (Лиса, 40), (Волк, 90), (Жираф, 800), (Слон, 1500),

(Кит, 3000) – порядок не соблюден

Вариант сортировки 2:(Лиса, 40), (Барсук, 40), (Волк, 90), (Жираф, 800), (Слон, 1500),

(Кит, 3000) – порядок соблюден

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

9

Алгоритмы на основе сравнений (Comparison sort): Bubble Sort, Selection Sort, Insertion Sort, Shell Sort, QuickSort, MergeSort, HeapSort и др.

Алгоритмы не основанные на сравнениях: Counting Sort, Radix Sort – используют структура ключа

Утверждение. Любой алгоритм сортировки, основанный на сравнениях, имеет асимптотическую вычислительною сложность (nlogn)

[*] Donald Knuth. The Art of Computer Programming, Volume 3: Sorting andSearching, Second Edition. Addison-Wesley, 1997 (Section 5.3.1: Minimum-Comparison Sorting, pp. 180–197).

Вычислительная сложность сортировки

10

АлгоритмЛучший случай

Средний случай

Худший случай

Память Свойства

Пузырьковаясортировка (Bubble sort)

O(n) O(n2) O(n2) O(1)Устойчивый, “на месте”

Сортировка вставками (Insertion Sort)

O(n) O(n2) O(n2) O(1)Устойчивый,“на месте”,

online

Сортировка выбором (Selection Sort)

O(n2) O(n2) O(n2)O(1)

Неустойчивый, “на месте”

Сортировка Шелла (Shell Sort)

O(n) O(n(logn)2),O(n3\2)

O(n3\2)O(1)

Неустойчивый, “на месте”

Быстрая сортировка(Quick Sort)

O(nlogn) O(nlogn) O(n2) O(logn)Устойчивость

зависит от реализации

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

O(nlogn) O(nlogn) O(nlogn) O(n)Зависит от

реализации

Пирамидальная сортировка (Heap sort)

O(nlogn) O(nlogn) O(nlogn) O(1)“На месте”,

неустойчивый

“Пузырьковая” сортировка (Bubble Sort)

11

function BubbleSort(v[0:n - 1], n)

swapped = True

while swapped do

swapped = False

for i = 1 to n - 1 do

if v[i - 1] > v[i] then

swap(v[i - 1], v[i])

swapped = True

end if

end for

end while

end function

9

5

54

23

45

2

4

4

42

34“Легкие” элемент перемещаются

(всплывают) в начало массива

TBubbleSort = O(n2)

Сортировка вставками (Insertion Sort)

12

function InsertionSort(v[1:n], n)

for i = 1 to n do

j = i

while j > 0 and v[j - 1] > v[j] do

swap(v[j - 1], v[j])

j = j - 1

end while

end for

end function Элемент v[j] перемещается в требуемую позицию уже упорядоченного массива

v[1] ≤ v[2] ≤ … ≤ v[j – 1] --- куда вставить v[j]?

4 15 2 35 88 4 17 23 62 13

j = 2

TInsertionSort = O(n2)

Быстрая сортировка (Quick Sort)

13

1. Из элементов v[1], v[2], …, v[n] выбирается опорный элемент (pivot element)

Опорный элемент желательно выбирать так, чтобы его значение было близко к среднему значению всех элементов

Вопрос о выборе опорного элемента открыт(первый/последний, средний из трех, случайный и т.д.)

2. Массив разбивается на 2 части: элементы массива переставляются так, чтобы элементы расположенные левее опорного были не больше (<=), а расположенные правее –не меньше него (>=). На этом шаге определяется граница разбиения массива.

3. Шаги 1 и 2 рекурсивно повторяются для левой и правой частей

Быстрая сортировка (Quick Sort)

14

function QuickSort(v[1:n], n, l, r)

if l < r then

k = Partition(v, n, l, r) // Разбиваем

QuickSort(v, n, l, k - 1) // Левая часть

QuickSort(v, n, k + 1, r) // Правая часть

end if

end function

QuickSort(1, n)

QuickSort(l, k – 1) QuickSort(k + 1, r)

Худший случай: TQuickSort = O(n2) Средний случай: TQuickSort = O(nlogn)

Быстрая сортировка (Quick Sort)

15

function Partition(v[1:n], n, l, r)

pivot_idx = r /* Выбрали индекс опорного элемента */

swap(v[pivot_idx], v[r])

pivot = v[r]

i = l – 1

for j = l to r – 1 do

if v[j] <= pivot then

i = i + 1

swap(v[i], v[j])

end if

end for

swap(v[i + 1], v[r])

return i + 1

end function

2 8 7 1 3 5 6 4

l = 1i = 0

r = npivot = 4

2 1 7 8 3 5 6 4

j = 1: swap(v[1], v[1])

j = 4: swap(v[2], v[4])

j = 5: swap(v[3], v[5])

2 1 3 8 7 5 6 4

swap(v[4], v[8])

2 1 3 4 7 5 6 8

return 4

Сортировка слиянием (Merge Sort)

1616

function MergeSort(a[0:n - 1], n)

if n > 1 then

k = n / 2

Copy(a[0, k - 1], b[0, k - 1]) // a -> b

Copy(a[k, n - 1], c[0, k - 1]) // a -> c

MergeSort(b) // Сортируем левую часть

MergeSort(c) // Сортируем правую часть

Merge(b, c, a) // Сливаем части

end if

end function

Вычислительная сложность сортировки слиянием в худшем случае (worst case)

TMergeSort = O(nlogn)

Доказательство оценки сложности см. [Levitin, С. 169]

Сортировка слиянием (Mergesort)

1717[*] Левитин А.В. Алгоритмы: введение в разработку и анализ [Levitin, С. 171]

MergeSort

Merge

MergeSort

MergeSort MergeSort MergeSort

Merge

MergeSort MergeSort

MergeMerge

MergeMerge

Сортировка слиянием (Mergesort)

1818

function Merge(b[0:p-1], c[0:q-1], a[0:n-1], p, q, n)// p + q <= ni = j = k = 0while i < p and j < q do

if b[i] ≤ c[j] thena[k] = b[i]i = i + 1

elsea[k] = c[j]j = j + 1

end ifk = k + 1

end whileif i = p then

Copy(c[j, q - 1], a[k, p + q - 1])else

Copy(b[i, p - 1], a[k, p + q - 1])end if

end function

Сортировка подсчетом (Counting Sort)

19

Сортировка подсчетом (Counting Sort) –алгоритм сортировки не использующий операцию сравнения элементов (non-comparision sort)

Применим к массивам, сортируемые элементы которых принимают неотрицательные целочисленные значения и не превосходят значения k

АлгоритмХудший случай

Память Свойства

Сортировка подсчетом

(Counting Sort)O(n + k) O(k) Устойчивый

Сортировка подсчетом (Counting Sort)

20

function CountingSort(v[0:n - 1], n, k)

for i = 0 to k – 1 do

c[i] = 0

end for

for i = 0 to n – 1 do

c[v[i]] = c[v[i]] + 1

end for

for i = 1 to k – 1 do

c[i] = c[i] + c[i - 1]

end for

for i = n - 1 to 0 do

c[v[i]] = c[v[i]] - 1

b[c[v[i]]] = v[i]

end for

2 11 7 1 3 5 6 3

n = 8, k = 11

0 1 1 2 0 1 1 1 0 0 0 1

c[0:k]:

0 1 2 4 4 5 6 7 7 7 7 8

c[0:k]:

b[0:n-1]:

Входной массив v[0:n–1] должен содержать целые числа от 0 до k – 1 (включительно)

1 2 3 3 5 6 7 11

Сортировка подсчетом (Counting Sort)

21

function CountingSort(v[0:n - 1], n, k)

for i = 0 to k – 1 do

c[i] = 0

end for

for i = 0 to n – 1 do

c[v[i]] = c[v[i]] + 1

end for

for i = 1 to k – 1 do

c[i] = c[i] + c[i - 1]

end for

for i = n - 1 to 0 do

c[v[i]] = c[v[i]] - 1

b[c[v[i]]] = v[i]

end for

2 11 7 1 3 5 6 3

n = 8, k = 11

0 1 1 2 0 1 1 1 0 0 0 1

c[0:k]:

0 1 2 4 4 5 6 7 7 7 7 8

c[0:k]:

b[0:n-1]:

TCountingSort = O(n + k)

1 2 3 3 5 6 7 11

Домашнее чтение

22

[AHU, C. 228-247]: Глава 8. Сортировка – разделы 8.1 – 8.4 (простые схемы сортировки, QuickSort, HeapSort)

[Levitin, С. 169]: Сортировка слиянием

Задание 1. Алгоритмы сортировки

23

Реализовать три алгоритма сортировки (по вариантам) и экспериментально исследовать их эффективность

Deadline: 10 марта 2014 г., 23:59 NSK (понедельник)

Внимание! Attention! Achtung! 關注! Atención!На выполнение задания отведено 3 недели —это всего 2 встречи на лабораторных работах (3 и 10 марта) и, соответственно, всего две возможности защитить отчет в срок!