Ministerul Educaţiei, Culturii și Cercetării al Republicii Moldova

Universitatea Tehnică a Moldovei

Departamentul Informatică și Ingineria Sistemelor

RAPORT
Lucrarea de laborator nr. 6
La Structuri de Date și Algoritmi

A efectuat:
st. gr. CR-211 Bivol Vasile

A verificat:
dr., conf. univ. Mihail Kulev

Chişinău -2022
 Lucrare de Laborator nr 6
Tema:
Analiza empirică a algoritmilor de sortare și de căutare
Scopul lucrării:
Studierea posibilităţilor şi mijloacelor limbajului C de programare a algoritmilor de sortare și de
căutare pentru tablouri unidimensionale și obținerea deprinderilor de analiză empirică a
algoritmilor.
Condiţia problemei (sarcina de lucru):
Să se scrie un program în limbajul C pentru analiza empirică a algoritmului
propus (după variantă) cu crearea funcţiei de căutare sau sortare pentru tabloul
unidimensional de n elemente cu afişarea la ecran a următorului meniu de opţiuni:
1. Tabloul demonstrativ de n elemente (5<= n <=20).
2. Tabloul cu valori aleatorii (n=10000, n=100000, n=1000000).
3. Tabloul sortat crescător (n=10000, n=100000, n=1000000).
4. Tabloul sortat descrescător (n=10000, n=100000, n=1000000).
5. Analiza empirică a funcției de sortare qsort() sau a funcției de căutare bsearch()
din biblioteca standard a limbajului C.
0. Ieșire din program.
Analiza empirică a algoritmului constă în: a) determinarea timpului de rulare,
numărului de comparații, numărului de schimbări (sau deplasări) de elemente
pentru tablouri cu 3 diferite seturi de valori și cu 3 diferite volume de elemente; b)
compararea și analiza rezultatelor obținute uilizând funcția creată și funcția din
biblioteca standard a limbajului C; c) tragerea concluziilor.

Varianta :
3. Sortare bulelor în ordine ascendentă.

Mersul lucrării:

Noţiuni din teorie şi metode folosite conform temei lucrării:

1. La realizarea operaţiei de afişare la ecran a informaţiei referitor la nodurile arborelui a
se prevedea și afişarea adreselor din memorie ale nodului curent precum și fiilor stâng şi drept ai
nodului curent.
2. Funcțiile de prelucrare ale arborelui binar oarecare trebuie implementate folosind algoritmi
iterativi în 2 versiuni:
a) utilizînd coada - pentru parcurgerea arborelui “în lățime” (parcurgerea arborelui pe niveluri);
b) utilizând stiva – pentru parcurgerea arborelui “în adîncime” (parcurgerea “în inordine”:
rădăcină -> subarbore stâng(drept) -> subarbore drept(stâng). O excepție face funcția de eliberare
a memoriei dinamice alocate pentru arbore (trebuie folosită parcurgerea “în postordine”:
subarbore stâng(drept) -> subarbore drept(stâng) -> rădăcină).
 Codul (textul, listing-ul) programului în limbajul C:
#include<stdio.h>
#include <stdlib.h>
#include <limits.h>
#include<time.h>

void afis(int n,int* A);

void insertionc(int *a, int n);
void insertiond(int *a, int n);
int* randomTab(int size);

int cmpfun(const void * a, const void * b)

{
return ( *(int*)a - *(int*)b );
}

long long comparatii,schimbari;

int main()
{
int nm, i, key = 20;
long n;
long times;
int *A = NULL, *B = NULL;

printf("\t\tMenu:\n");
printf(" 1. Tablou demonstrativ \n");
printf(" 2. Tablou cu valorii
aleatorii(n=1000,n=10000,n=100000) \n");
printf(" 3. Sortarea tabloului
crescator(n=1000,n=10000,n=100000) \n");
printf(" 4. Sortarea tabloului descrescator
(n=1000,n=10000,n=100000) \n");
printf(" 5. Analiza empirica a functiei de sortare \n");
printf(" 0. Exit \n ");

while(1)
{
printf("\n\t Optiunea: ");
scanf("%d",&nm);
switch(nm)
{
case 1:
 {
printf("\t\tTablou Demonstrativ: \n");

printf("Introdu numarul de elemente ale tabloului unidimensional:");

scanf("%d",&n);
A = (int *)malloc(n * sizeof(int));
if(!A)
{
printf("\nMemoria nu a fost alocata \n");
}
else
{
printf("Memoria a fost alocata \n");
}

srand(time(NULL));

for(int i = 0; i < n; i++)

{
A[i] = rand() % 50;
}

printf("\n");
afis(n,A);

printf("\n\n Tabloul sortat:\n");

times = clock();
insertionc(A,n);
times = clock() - times;
afis(n,A);
printf("\n Timpul de efectuare: %ld secunde Comparatii:%lld Schimbari:
%lld ;\n", times/CLOCKS_PER_SEC,comparatii,schimbari);
break;
}
case 2:
{
n = 1000;
while(n != 1000000)
{
times = clock();
B = randomTab(n);
times = clock() - times;
printf("Tabloul cu valori aleatorii din %ld elemente a fost creat in %ld
secunde\n",n, times/CLOCKS_PER_SEC);
n *= 10;
 }
break;
}
case 3:
{
n = 1000;
while(n != 1000000)
{
printf("N = %d\n",n);
B = randomTab(n);

times = clock();
insertionc(B,n);
times = clock() - times;
printf("Timpul de efectuare: %ld secunde Comparatii:
%lld Schimbari:%lld ;\n",
times/CLOCKS_PER_SEC,comparatii,schimbari);
free(B);
n *= 10;
}
break;
}
case 4:
{
{
n = 1000;
while(n != 1000000)
{
printf("N = %d\n",n);
B = randomTab(n);
times = clock();

insertiond(B,n);

times = clock() - times;

printf("Timpul de efectuare: %ld secunde Comparatii:
%lld Schimbari:%lld ;\n",
times/CLOCKS_PER_SEC,comparatii,schimbari);
free(B);
n *= 10;
}
break;
}
}
 break;
case 5:
{
n = 1000;
while(n != 1000000)
{
B = randomTab(n);
insertiond(B,n);
times = clock();
bsearch(&key,B,n,sizeof(int),cmpfun);
times = clock() - times;
free(B);
printf("elementul din tabloul cu valori aleatorii din %ld elemente a fost gasit
in %ld secunde\n",n, times/CLOCKS_PER_SEC);
n *= 10;
printf("\n");
}
break;
}
case 0:
{
free(A);
free(B);
exit(0);
}
default:
{
printf("Optiune gresita!");
break;
}
}
}
}

void swap(int* xp, int* yp)

{
int temp = *xp;
*xp = *yp;
*yp = temp;
}

void bubbleSort(int a[], int n)

{
int i, j;
for (i = 0; i < n - 1; i++)
 for (j = 0; j < n - i - 1; j++)
if (a[j] > a[j + 1])
swap(&a[j], &a[j + 1]);
}

void afis(int n,int* A)

{
int i;
for(i = 0; i < n; i++)
{
printf("%d ",A[i]);
}
}

void insertionc(int *a, int n)

{
float times;
comparatii = 0;
schimbari = 0;

int i, j, aux;
for (i = 1; i < n; i++)
{
j = i;
while(j > 0)
{
comparatii++;
if(a[j - 1] > a[j])
{
aux = a[j];
a[j] = a[j - 1];
a[j - 1] = aux;
schimbari++;
}
j--;
}

}
}

void insertiond(int *a, int n)

{
float times;
comparatii = 1;
 schimbari = 0;

int i, j, aux;
for (i = 1; i < n; i++)
{
j = i;
while(j > 0)
{
comparatii++;
if(a[j - 1] < a[j])
{
aux = a[j];
a[j] = a[j - 1];
a[j - 1] = aux;
schimbari++;
}
j--;
}

}
}

int* randomTab(int n)
{
srand(time(NULL));
int *tab = (int *)malloc(n * sizeof(int));
if(!tab)
{
printf("\n Memoria nu a fost alocata \n");
}
else
{
for(int i = 0; i < n; i++)
{
tab[i] = rand() % 20;
}
}
return tab;
}

Rezultatele testării și funcţionării programului:

 Analiza rezultatelor și concluzii:

1. Programul dat a avut o strcutură asemănătoare cu cel din lucrarea de laborator trecută,
ceea ce a permis iar împărțirea codului în trei părți și economisirea locului.
2. Mulțumită implementării header-ului și a funcțiilor în main a fost posibilă folosirea unui
document cu mult mai scurt, comparative cu cel din laboratorul numărul 6.

Bibliografie:
1. https://else.fcim.utm.md/mod/assign/view.php?id=32769
2. https://else.fcim.utm.md/course/view.php?id=379
3. https://www.coursehero.com/file/p4l8ln5q/%C8%99i-de-utilizare-a-tipului-abstract-
de-date-TAD-Arbore-binar-cu-asigurarea/
4. http://repository.utm.md/bitstream/handle/5014/15229/
ProgramareaCalculatoarelor_StructuriDateAlgoritmi_C_DS.pdf?sequence=1
5. http://www.cs.ubbcluj.ro/~gabis/fp/Documentatii/TAD.pdf
6. https://else.fcim.utm.md/mod/assign/view.php?id=32768