Evaluarea i msurarea timpului de execuie al unui algoritm

1. Consideraii teoretice
De multe ori, pentru rezolvarea unei probleme, trebuie ales un algoritm dintre mai multi
posibili, doua criterii principale de alegere fiind:
1. Algoritmul sa fie simplu de inteles, de codificat si de depanat;
2. Algoritmul sa foloseasca eficient resursele calculatorului, sa aiba un timp de executie
redus.
Daca programul care se scrie trebuie rulat de un numar mic de ori, prima cerinta este mai
importanta.
Daca programul urmeaza a fi rulat de un numar mare de ori, avand si un numar mare de date
de prelucrat, trebuie ales algoritmul care duce la o executie mai rapida. Chiar in aceasta situatie,
ar trebui implementat mai inainte algoritmul mai simplu si calculata reducerea de timp de
executie pe care ar aduce-o implementarea algoritmului complex.
Timpul de rulare al unui program depinde de urmatorii factori:
datele de intrare;
calitatea codului generat de compilator;
natura si viteza de executie a instructiunilor programului;
complexitatea algoritmului care sta la baza programului.
Deci timpul de rulare, de cele mai multe ori, nu depinde de valorile de intrare, ci de numarul
de date.
Se noteaza cu T(n) timpul de rulare al unui program, ale carui date de intrare au
dimensiunea n.
Studierea complexitatii presupune analiza completa in cadrul algoritmului a urmatoarelor trei
aspecte:
1. configuratia de date cea mai defavorabila (cazurile degenerate);
2. configuratia de date cea mai favorabila;
3. comportarea medie.
Comportarea medie presupune probabilitatea de aparitie a diferitelor configuratii de date la
intrare. Aspectul 1 este cel mai studiat si este folosit, de obicei, pentru compararea algoritmilor.
Complexitatea unui algoritm secvential se exprima de regula in limbajul ordinului O.
Pentru calculul complexitatii se va incerca incadrarea in clasa cea mai mica de complexitate
din acest sir:
O(1) clasa algoritmilor constanti;
O(log n) clasa algoritmilor logaritmici;
O(n) clasa algoritmilor liniari;
O(nlog n) clasa algoritmilor polilogaritmici;
O(n2 ) clasa algoritmilor patratici;
O(nk log n) clasa algoritmilor polilogaritmici;
O(nk+1) clasa algoritmilor polinomiali;
O(2n) clasa algoritmilor exponentiali.
Reguli de determinare a timpului de executie T(n) si O(f(n))

Daca T1(n) si T2(n) sunt timpii de executie a doua secvente de program P1 si P2, T1(n)
fiind O(f(n)), iar T2(n) fiind O(g(n)), atunci timpul de executie T1(n)+T2(n), al secventei P1
urmata de P2, va fi O(max(f(n),g(n))).
Exemplu
Avind trei secvente de program cu timpii O(n 3), O(n2) si O(n*log n), conform regulii
anterior prezentate, timpul total de executie a celor trei secvente va fi O(max(max(n 3,n2),n*log
n))= O(max(n3,n*log n))=O(n3).
Cateva reguli generale pentru evaluarea timpului de executie, functie de marimea n a datelor
de intrare, sunt:
(1) timpul de executie al unei instructiuni de asignare, citire sau scriere, este O(1);
(2) timpul de rulare al unei secvente de instructiuni e determinat de regula de insumare, fiind
proportional cu cel mai lung timp din cei ai instructiunilor secventei;
(3) timpul de executie al unei instructiuni if-then-else este suma dintre timpul de evaluare a
conditiei (O(1)) si cel mai mare dintre timpii de executie ai instructiunilor pentru conditie
adevarata sau falsa;
(4) timpul de executie al unei instructiuni de ciclare este suma, pentru toate iteratiile, dintre
timpul de executie a corpului instructiunii si cel de evaluare a conditiei de terminare
(O(1));
(5) pentru evaluarea timpului de executie a unei functii recursive, se asociaza fiecarei functii
recursive un timp necunoscut T(n), unde n masoara argumentele functiei; se poate obtine
o relatie recurenta pentru T(n), adica o ecuatie pentru T(n), in termeni T(k), pentru
diferite valori ale lui k.
2. Exerciii
1.
int sum(int N)
{
int s=0;
s=N*(N+1)/2;
return s;
}
Complexitate: O(1)

1
4
1

int sum(int N)
{
int s=0;
for(int i=1;i<=N;i++)
{
s=s+i;
}
return s;
}
Complexitate: O(n)

1
n+1
n
1

2.
int x = 0;
for ( int j = 1; j <= n/2; j++ )
for ( int k = 1; k <= n*n; k++ )
x = x + j + k;
3.
int x = 0;
for ( int j = 1; j <= n; j++ )
for ( int k = 1; k < 3*j; k++ )
x = x + j;
4.
int isNumberEven(int no)
{
if(no % 2 == 0)
return 1;
else
return 0;
}
5.
for (i = 0; i < N; i++) {
sequence of statements
}
for (j = 0; j < M; j++) {
sequence of statements
}
6.
for (i = 0; i < N; i++) {
for (j = 0; j < N; j++) {
sequence of statements
}
}
for (k = 0; k < N; k++) {
sequence of statements
}
7.
for (i = 0; i < N; i++) {
for (j = N; j > i; j--) {
sequence of statements
}
}

8.
int i = N;
while (i > 0)
{
int Sum = 0;
int j;
for (j = 0; j < i; j++)
Sum++;
cout<< Sum <<endl;
i--;
}
9.
length[A]=n;
for i = 0 to length[A] - 1
k = i + 1
for j = 1 + 2 to length[A]
if A[k] > A[j]
k = j
if k != i + 1
temp = A[i + 1]
A[i + 1] = A[k]
A[k] = temp
10.
int result=0;
for (int i=0; i<N; i++)
for (int j=i; j<N; j++) {
for (int k=0; k<M; k++) {
int x=0;
while (x<N) { result++; x+=3; }
}
for (int k=0; k<2*M; k++)
if (k%7 == 4) result++;
}
11.
for(i=0;i<n-1;i++)
for(j=0;j<n-i-1;j++)
{
if(a[j]>a[j+1]){
t=a[j];
a[j]=a[j+1];
a[j+1]=t;
}
}
12.
Y 0

j n
while j >= 1 do
k 0
while
y y
k k
}
j j 1
}
return y

{
k < n*n do {
+ j k
+ 1

13.
long factorial(int n)
{
long f=1;
for (int i=1;i<=n;i++)
f=f*i;
return f;
}
14.
long factorial(int n)
{
if(n<=1)
return 1;
else
return n*factorial(n-1);
}
15.
int search(int* v, int n,int a){
int i=0;
while(i<n){
if(v[i]==a){
return i;
}
i++;
}
return -1;
}
16. int binary_search(int A[], int key, int imin, int imax)
{
if (imax < imin)
return KEY_NOT_FOUND;
else

{
int imid = midpoint(imin, imax);
if (A[imid] > key)
return binary_search(A, key, imin, imid - 1);
else if (A[imid] < key)
return binary_search(A, key, imid + 1, imax);
else
return imid;
}
}
3. Tema
Implementati algoritmii Bubble sort, Quicksort si cautarea binara a unui element intrun vector. Pentru fiecare algoritm generati un fisier .txt cu urmatoarea structura:
Dimensiunea_de_testare(n)\tTimp_de_executie(T(n))
Exemplu:
3
55,43
5
63,75
7
75,23
.
.
.
.
100
x
Reprezentati grafic rezultatele.