1.Трудоемкость алгоритмов

Размер входа - число ячеек памяти, заним вход данными при разумном кодировании.

Элементарные операции:

1) Вызов функции

2) Логические операции

3) Арифметические операции

4) Операции присваивания

5) Обращение к элементу массива по его индексу

Время работы алгоритма на входных данных X – это число элементарных операций, выполняемых алгоритмом при обработке X.

Трудоемкость в худшем случае

Пусть имеется некоторый алгоритм A

T_A: N®N T_A(n) – максимальное время работы алгоритма A на входе размера n

T_A(n) – трудоемкость алгоритма A

O-символика

f(n) = O(g(n)) если и только если существует константа С>0 такая, что f(n)£Cg(n) для любого n. Если T_A(n) = O(g(n)), то говорят, что O(g(n)) – временнáя сложность алгоритма A. Это значит, что в самом худшем случае на входе размера n наш алгоритм будет работать не более Сn времени.

Распространенные сложности алгоритмов

Пусть n – размер входа алгоритма

1. O(n) – линейная сложность

2. O(n^k) – полиномиальная сложность

3. O(kⁿ) – экспоненциальная сложность

4. O(nlogn), O(n!),…

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

Вход: массив элементов (a₁,…,a_n), принадлежащих некоторому вполне упорядоченному множеству S

Выход: перестановка этих элементов (b₁,…,b_n) такая, что b_i£b_i+1, i=1,…,n-1.

Сортировка вставками

Идея: на i-м каждом шаге элемент a_i вставляется на свое место в уже отсортированный подмассив (a₁,…,a_i-1)

for (i=2; i£n; i++)

{

curr = a[i];

j = i-1;

while ((j>0) && (a[j] > curr))

{

a[j+1] = a[j];

j--;

}

a[j+1] = curr;

}

На i-м шаге в худшем случае выполняется С*(i-1) операций

T = C + 2C +…+C(n-1) = Cn(n-1)/2 = O(n(n-1)/2)

Трудоемкость в среднем - O(n(n-1)/4).

Дерево алгоритма сортировки:

1)Внутренние вершины получают метки (i,j). Такая

вершина соответствует операции сравнения элементов

a_i и a_j. Корень соответствует самой первой операции

сравнения.

2) Каждый лист соответствует результату работы

алгоритма и получает пометку (b₁,…,b_n), где (b₁,…,b_n) –

пересатновка элементов массива, получившаяся в

результате выполнения алгоритма.

3) Каждое ребро получает метку £ или > в соответствии

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

вершине, из которой это ребро выходит

Трудоемкость в худшем случае – длина самого длинного

пути из корня дерева в его лист (высота дерева)

Лемма. Пусть высота дерева c L листьями равна h. Тогда L£2^h.

В дереве алгоритма число листьев равно n!. L = n! £ 2^h

Метод “разделяй и властвуй”

1. Разделение задачи на несколько подзадач

2. Решение этих подзадач (например, рекурсивно)

3. Комбинирование решений подзадач и получение из них решения исходной задачи

QuickSort

Пусть A[p…r] = (a_p,…,a_r) A=A[1…n]

1.Переупорядочеваем подмассив A[p…r] таким образом, чтобы существовал qÎ [p,r] такой, что для любого iÎ [p,q-1] a_i£a_q и для любого jÎ [q+1,r] a_q£a_j

Quicksort(A,p,r)

{

if (p < r)

{

q = Findq(A,p,r);

QuickSort(A,p,q-1);

QuickSort(A,q+1,r);

}

}

Quicksort(A,1,n)

x = A[r]; q = p;

for (i=p; i<=r;i++)

{

if (A[i]<=x)

{

swap(A[i],A[q]);

q++;

}

}

Трудоемкость процедуры Findq - Cm = O(m), где m=r-p

2.Cортируем подмассивы A[p…q-1] и A[q+1…r]

Худшая трудоемкость у алгоритма QuickSort будет тогда, когда на каждом шаге Findq будет генерировать разбиение массива A[p…r] на подмассивы из 1 элемента и m-1 элемента

Трудоемкость в худшем – T(n) = Cn + C + T(n-1) = O(n²)

В лучшем случае разбивает массив на 2 подмассива примерно равной длины. Тогда T(n) = Cn + 2T(n/2)

Лемма. Решение этого рекуррентного уравнения – O(nlogn)

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

T(n) = O(max_i=1,…,n(a[i])*n)