Принципи на анализа на алгоритми
Веселина Стоянова

1. Илюстрация на процеса

2. Описание на използваните математически понятия

3. Сравняване на алгоритми

Емпиричен анализ

ü Коректен и пълен код

ü Входни данни – действителни, случайни, лоши данни

Защо анализираме алгоритмите математически?

ü За да сравняваме различни алгоритми за една и съща задача

ü За да предвиждаме производителността в нова среда

ü За да задаваме стойности на параметрите на алгоритъма

Елементи на анализа на алгоритми

1. Избор на абстрактни операции

2. Моделиране на входа:

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

ü Най-лош случай

Нарастване на функции

Главен параметър N – пропорционален на размера на обработваните данни (степен на полином, размер на файл или масив, брой символи в низ и др.)

Най-често срещани функции при оценка времето на работа на алгоритъма:

ü 1 – времето за работа на алгоритъма е константа

ü logN – логаритмично време при разделяне задачата на малки подзадачи

ü N – линейно време – всеки входен елемент се обработва по малко

ü NlogN – задачата се разделя на подзадачи, всяка от които се решава независимо, а после решението се обединява

ü N² – квадратично време – например обработване на всички двойки от данни (2 вложени цикъла)

ü N³ – кубично време – аналогично с тройки от данни

ü 2^N – експоненциално време – решения с груба сила

секунди
10^2	1.7 мин.
10^4	2.8 часа
10^5	1.1 дни
10^6	1.6 седмици
10^7	3.8 месеца
10^8	3.1 години
10^9	3.1 десетилетия
10^10	3.1 века
10^11	Никога (3.1 хилядолетия)

Други функции:

ü N^3/2 - алгоритъм с вход N² и време за изпълнение пропорционално на N³, се описва като алгоритъм от степен N^3/2.

ü Nlog²N – задачи с 2 етапа на разбиване на подзадачи

Ще означаваме двоичния логаритъм по следния начин: log₂NºlgN

ëxû - закръгляне надолу

éхù - закръгляне нагоре

élgNù - брой на битовете в двоичното представяне на N

- хармонични числа (дискретизирана версия на lnN)

Дефиниция 1. За функцията g(N) се казва, че е O(f(N)), ако съществуват константи c₀ и N₀ такива, че g(N)<c₀f(N) за всяко N>N_0.

Приложения на О:

ü За ограничаване на грешката, която допускаме, пренебрегвайки малките членове във формулите

ü За ограничаване на грешката, която допускаме, пренебрегвайки части от програмата, които имат малко значение за цялостния анализ

ü За класифициране на алгоритмите по горната граница на времето им за работа

Пример: (N+O(1)) (N+O(logN)+O(1))=

=N²+O(N)+O(N logN)+O(logN)+O(N)+O(1)»

» N²+O(N logN) – асимптотичен израз (с 1 член О)

Пример: Даден е алгоритъм с 2 цикъла: вътрешен (изпълнява се средно по 2NH_N пъти) и външен (изпълнява се N пъти) и инициализация (изпълнява се 1 път). Нека всяка итерация на вътрешния цикъл изисква а₀ наносекунди, външния – а₁ наносекунди, а инициализацията – а₂ наносекунди. Тогава общо времето за работа е t=2a₀NH_N+a₁N+a₂= 2a₀NH_N+O(N)

H_N=lnN+O(1)

t=2a₀NlnN+O(N)

Основни рекурсии

1. C_N=C_N-1+N, за N³2 при С₁=1 (програми, които циклят входа, за да премахнат 1 елемент)

C_N=C_N-1+N=

=C_N-2+(N-1)+N=

= C_N-3+(N-2)+(N-1)+N=

…

=C₁+2+…+(N-2)+ (N-1)+N=

=1+2+…+(N-2)+ (N-1)+N=

2. C_N=2C_N/2+1, за N³2 при С₁=1 (програми, които разполовяват входа на всяка стъпка)

C_N=O(lgN). Предполагаме N=2ⁿ

…

=n+1

3. C_N=C_N/2+N, за N³2 при С₁=0 (програми, които разполовяват входа на всяка стъпка, но вероятно трябва да изследват всички елементи във входа)

C_N=N+N/2+N/4+….=O(2N)

4. C_N=2C_N/2+N, за N³2 при С₁=0 (програми, които обхождат линейно входа и го разполовяват на всяка стъпка), например алгоритми “разделяй и владей”

…

=n

Примери за анализ на алгоритми:

1. Последователно търсене

int search (int a[], int v, int l, int r)

{ for (int i=l; i<=r; i++)

if (v==a[i]) return I;

return –1;

}

при неуспешно търсене – N елемента; при успешно – средно по N/2

2. Двоично търсене

int search (int a[], int v, int l, int r)

{ while (r>=l)

{ int m=(l+r)/2;

if (v==a[m]) return m;

if (v<a[m]) r=m-1;

else l=m+1;

}

return –1;

}

изследват се не повече от ëlgNû+1 числа

3. Сортиране чрез селекция

const int size=100;

int min_position (int a[], int from, int to)

{ int min_pos=from;

for (int i=from+1; i<=to; i++)

if (a[i]<a[min_pos]) min_pos=i;

return min_pos;

}

void selection_sort (int& a[])

{ for (int next=0; next<size; next++)

{ int min_pos=min_position (a, next, size-1);

if (min_pos!=next)

{ int temp=a[min_pos];

a[min_pos]=a[next];

a[next]=temp;

}

}

}

Общ брой операции:

n+2+(n-1)+2+….+2+2=

=n+(n-1)+…+2+(n-1)2=

=-1+(n-1)2=

==O(n²)

4. Сортиране чрез сливане

void merge (int& a[], int from, int mid, int to)

{int n=to-from+1, b[size];

int i1=from, i2=mid+1;

int j=0;

while (i1<=mid and i2<=to)

{if (a[i1]<a[i2])

{b[j]=a[i1];

i1++;

}

else { b[j]=a[i2];

i2++;

}

while (i1<=mid)

{ b[j]=a[i1];

i1++;

j++;

}

while (i2<=to)

{ b[j]=a[i2];

i2++;

j++;

}

for (j=0, j<size; j++)

a[from+j]=b[j];

}

void merge_sort (int& a[], int from, int to)

{ if (from==to) return;

int mid=(from+to)/2;

merge_sort(a, from, mid);

merge_sort(a, mid+1, to);

merge(a, from, mid, to);

}

Брой операции: O(n lgn)