Universitatea Tehnică a Moldovei

Catedra Automatică și Tehnologii Informaționale

Disciplina Structuri de date şi algoritmi 

Varianta 19

Raport

Tema: Analiza complexităţii şi eficienţei algoritmilor ale TEHNICII PROGRAMĂRII”

A realizat student grupa TI-172 Rosca Florin

A verificat Moțpan Serghei

Chisinău 2018
Cuprin

2
 s

1. Scopul și obiectivele lucrării....................................................................................................3

2. Sarcina......................................................................................................................................4
3. Schema bloc.............................................................................................................................5
4. Realizarea.................................................................................................................................7
Concluzii..........................................................................................................................................8
Bibliografie......................................................................................................................................9
Anexa A.........................................................................................................................................10
Anexa B.........................................................................................................................................11

3
1. Scopul și obiectivele lucrării

 de studiat şi însuşit materialul teoretic pentru evidenţierea esenţialului evaluării tehnicilor

de programare în elaborarea modelelor eficiente a soluţiei problemelor: esenţa m etodelor
(strategiilor tehnicilor de apreciere) şi specificul realizării ;
 să se analizeze complexitatea asimptotică şi notaţiile ei ca să se definească tehnica modelării
timpului de execuţie prin analiza empirică şi scenariile programării eficiente prin calculul
timpului de execuţie pentru diverşi algoritmi cu argumentări şi modele de structuri
abstracte;
 să se preia varianta problemei din Ll6 SDA pentru analiza empirică a complexităţii
algoritmilor şi calculul timpului de execuţie , implementând funcţiile de timp C, şi rularea
programelor în limbajul C
 să se elaboreze scenariile succinte de modificare, utilizând pointeri, subprograme şi
fişiere cu teste de verificare şi vizualizări şi explicaţii la principalele subprograme prin
analiza comparativă.
 Folosiţi ceasul de timp real al sistemului pentru a estima performanţele algoritmului.
 În raport de descris concis esenţa fiecărei metode ( ca strategie sau tehnică de programare).


4
2. Sarcina

Să se elaboreze algoritmul şi programul pentru următoarele: Se cere sa se genereze toate

descompunerile numarului natural n ca suma de numere naturale (doua partitii difera fie prin
valoarile elementelor din partitie, fie prin ordinea acestora) . Si de calculat complexitatea programului
dat.

5
 3. Schema bloc

Figura 1 Schema bloc pentru

functia main();

Figura 2 Schema bloc pentru functia back();

6
4. Realizarea

Realizarea programului este descrisa in laboratoru Nr.6 ,aici eu doar am analizat programul
dupa criteriile de calcul a complaxitatii algoritmelor:
1. Se stabileşte dimensiunea problemei.
2. Se identifică operaţia de bază.
3. Se verifică dacă numărul de execuţii ale operaţiei de bază depinde doar de
dimensiunea problemei. Dacă da, se determină acest număr. Dacă nu, se analizează
cazul cel mai favorabil, cazul cel mai defavorabil şi (dacă este posibil) cazul mediu.
4. Se stabileşte clasa de complexitate căruia îi aparţine algoritmul.
Deci mergind dupa aceste criterii in rezultam am primit urmatoarea formula a complexitatiii :
complexitatea fata de timpul de executie „ T(n)=O(n∗n!)=O(n!) ” iar din punct de
vedere al spatiului S(n)=O(n) ,deci pot afirma ca pentru rezolvare acestei probleme
backtrackingul este destul de optim deoarece complexitatea algoritmului este una
factoriala .

7
 Concluzii

Analiza complexitatii unui algoritm are ca scop estimarea volumului de resurse de calcul
necesare pentru executia algoritmului. Prin resurse se ıntelege:

• Spatiul de memorie necesar pentru stocarea datelor pe care le prelucreaza algoritmul.

• Timpul necesar pentru executia tuturor prelucrarilor specificate ın algoritm.

Aceasta analiza este utila pentru a stabili daca un algoritm utilizeaza un volum acceptabil
de resurse pentru rezolvarea unei probleme. In caz contrar algoritmul, chiar daca este corect, nu
este considerat eficient si nu poate fi aplicat ın practica. Analiza complexitatii, numita si analiza
eficientei algoritmilor, este utilizata si ın compararea algoritmilor cu scopul de a-l alege pe cel
mai eficient (cel care foloseste cele mai putine resurse de calcul).

8
 Bibliografie

1. The GNU C Reference Manual. [Interactiv] https://www.gnu.org/software/gnu-c-

manual/gnu-c-manual.html.
2. The C Library Reference Guide. [Interactiv] https://www-
s.acm.illinois.edu/webmonkeys/book/c_guide/.

[ CITATION The1 \l 1033 ]

Anexa A

Figura 3 Rezultatul executiei programului cu valoarea intervalului [1-101]

9
 Anexa B

#include <stdio.h>
#include <conio.h>
//Sa se genereze toate matricile nxn ce contin elemente distincte din multimea 1,...,n2
astfel incat pe fiecare linie elementele sa fie in ordine crescatoare.
int n,a[20][20],Nr=1;
//Funtia verifica daca noua matrice corespunde conditiei necesare
int posibil(int i,int j)
{ int l,k;
for(k=1;k<=i-1;k++)
for(l=1;l<=n;l++)
if (a[i][j]==a[k][l])
return 0;
if ((j) && (a[i][j]<=a[i][j-1]))
return 0;
return 1;
}
//Funtia afiseaza matricele generate pe ecran
void tiparire(void)
{ printf("\n");
printf("Matricea Nr.%d",Nr++);
int i , j;
for( i=1;i<=n;i++) {
printf("\n ");
for( j=1;j<=n;j++)
printf(" %d",a[i][j]);}
printf("\nTastati o tasta!\n");
getch();
}
//Funtia folosind metoda backtracking,creaza noile matrice si apoi cu ajutorul functiilor
anterioare verifica daca ea corespunde conditie si daca da o afiseaza pe ecran
void back(int i,int j)
{ int k;
for(k=1;k<=n*n;k++) {
a[i][j]=k;
if (posibil(i,j))
if ((i==n) && (j==n))
tiparire();
else
if (j==n)
back(i+1,1);
else
back(i,j+1);}
}
//Funtia principala ce lucreza cu funtiile anterioare
void main(void)
{ n=2;
clrscr();
back(1,1);
getch();
}

10