Ministerul Educației al Republicii Moldova

Universitatea Tehnică a Moldovei

Catedra Informatica Aplicată

RAPORT
Lucrarea de laborator nr.6
La Structuri de date si algoritmi

A efectuat:
st. gr. TI-15X Student Name

A verificat: M. Kulev
dr., conf.univ.,
 Chișinău 2016
Lucrarea de laborator nr.6

Tema: Analiza emperică a algoritmilor de sortare și de căutare

Scopul lucrarii: Obținerea deprinderilor de analiză emperică a algoritmilor

Sarcina de lucru: De scris un program in limbajul C pentru analiza emperică a algoritmului

propus (după variantă) care afișarea meniului cu următoarele obțiuni:

1. Tabloul demonstrativ de n elemente (n<=20)

2. Tablou cu valori aleatoare pentru trei numere n1, n2, n3 de elemente mari
(10000<n1<n2=2*n1<n3=2*n2)

3. Tablou sortat crescător

4. Tablou sortat invers (descrescător)

5. Analiza algoritmului funcției standard de sortare qsort() sau funcției standard de căutare
bsearch()

Analiza emperică a algoritmului constă în: determinarea timpului de rulare, numărului de

compărări, numărului de interschimbări (muțări), compărarea rezultatelor obținute și aranjate în
tabela și formularea concluziilor.

Varianta 10: Sortarea qsort

Noţiuni teoretice

Uneori analiza teoretică a eficienței este dificilă; în aceste cazuri poate fi utilă analiza empirică.
Analiza empirică poate fi utilizată pentru:
o Formularea unei ipoteze inițiale privind eficiența algoritmului
o Compararea eficienței a mai multor algoritmi destinați rezolvării aceleiași probleme
o Analiza eficienței unei implementări a algoritmului (pe o anumită mașina)
o Verificarea acurateții unei afirmații privind eficiența algoritmului
Structura generală a analizei empirice
1. Se stabilește scopul analizei
2. Se alege o măsură a eficienței (de exemplu, numărul de execuții ale unor operații sau timpul
necesar execuției unor pași de prelucrare)
3. Se stabilesc caracteristicile setului de date de intrare ce va fi utilizat (dimensiune, domeniu de
valori …)
4. Se implementează algoritmul sau în cazul in care algoritmul este deja implementat se adaugă
instrucțiunile necesare efectuării analizei (contoare, funcții de înregistrare a timpului necesar
execuției etc)
5. Se generează datele de intrare
6. Se execută programul pentru fiecare dată de intrare și se înregistrează rezultatele

1
7. Se analizează rezultatele obținute
Analiza datelor:

Functia main
a) date intermediare:
optiune – variabilă simplă de tip integer, opțiunea aleasă de utilizator
st,dr - variabile simple de tip integer

void WriteRev(char* fileName, int* d)

Functia de tip void pentru salvarea in fisier a datelor in ordine descrescatoare
Parametri
d- pointer de tip integer
fileName – pointer de tip char, in care se pastreaza informatia despre locatia fisierului care
urmeaza a fi deschis si scris de functie
Date returnabile: nu sunt
Variabile locale
k – variabila simpla de tip integer

void Write(char* fileName, int* d)

Functia de tip void pentru salvarea in fisier a datelor in ordine crescatoare
Parametri
d- pointer de tip integer
fileName – pointer de tip char, in care se pastreaza informatia despre locatia fisierului care
urmeaza a fi deschis si scris de functie
Date returnabile: nu sunt
Variabile locale
k – variabila simpla de tip integer

void ReadDataFromFile(char* fileName)

Functia de tip void pentru citirea din fisier in fisier a datelor
Parametri
fileName – pointer de tip char, in care se pastreaza informatia despre locatia fisierului care
urmeaza a fi deschis si scris de functie
Date returnabile: nu sunt
Variabile locale nu sunt

void ShowRaw(int* d)
Functia de tip void pentru afisarea datelor
Parametri
d- pointer de tip integer
Date returnabile: nu sunt
Variabile locale
i- variabila simpla de tip integer

void Swap(int *a,int *b);

Aceasta functie este de tip void pentru a interschimba 2 elemente
Parametri
a – pointer de tip int care reprezinta adresa elementului de interschimbare
b – pointer de tip int care reprezinta adresa elementului de interschimbare
Date returnabile: nu sunt
Variabile locale
t – variabila intermediara de tip int

2
void ShowResult(sort_measure_t data2)
Functia de tip void pentru afisarea rezultatelor
Parametri
data2- variabila de tip sort_measure_t
Date returnabile nu sunt
Variabile locale

void GenerateRandom(int num)

Functia de tip void pentru generarea aleatoare a elementelor
Parametri
num – variabila de tip int care reprezinta numarul elementelor
Date returnabile nu sunt
Variabile locale
i- variabila simpla de tip integer

sort_measure_t native_qsort()
Functia de tip sort_measure_t pentru soratrea elementelor
Parametri nu sunt
Date returnabile functia returneaza data
Variabile locale
data- variabila de tip sort_measure_t

sort_measure_t quicksort(int st, int dr)

Functia de tip sort_measure_t pentru soratrea prin quicksort.
Parametri
st,dr – variabile simple de tip integer
Date returnabile functia returneaza data
Variabile locale
data- variabila de tip sort_measure_t

void quicksort_raw(int st, int dr, sort_measure_t* data)

Functia de void pentru soratrea elementelor
Parametri
st,dr – variabile simple de tip integer
data – pointer de tip sort_measure_t
Date returnabile nu sunt
Variabile locale
i,j,m,aux- variabile simple de tip integre

3
Codul programului in limbajul C
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include <string.h>
#include<conio.h>
#define MAX 100000
const int DIM = 1337;
int rawData[MAX] = {0}, need[MAX] = {0}, n = 0;
clock_t currentTime = NULL;
FILE *f = NULL;
typedef struct sort_measure sort_measure_t;
struct sort_measure {
int permutations;
int iterations;
double time_spended;
char* sort_name;
};
void CopyRawToBeSorted() {
memcpy(need, rawData, sizeof(rawData));
//memset(sorted, 0, sizeof(sorted));
}
void WriteRev(char* fileName, int* d) {
int k=n;
f=fopen(fileName,"wt");
while (k--) {
fprintf(f,"%d\n",d[k]);
}
fclose(f);
}
void Write(char* fileName, int* d) {
int k=0;
f=fopen(fileName,"wt");
while (k < n) {
fprintf(f,"%d\n",d[k]);
k++;
}
fclose(f);
}
void ReadDataFromFile(char* fileName) {
n=0;
f=fopen(fileName,"rt");
while (!feof(f)) {
fscanf (f,"%d",&rawData[n]);
n++;
}
n--;
fclose(f);
}
void ShowRaw(int* d) {
int i;

4
 printf(" Lista elementelor\n");
for (i=0; i<n; i++) {
printf(" %d\t", d[i]);
}
printf("\n");
}
void Swap(int* a, int* b) {
int t = *a;
*a = *b;
*b = t;
}
void StartTime() {
currentTime = clock();
}
double StopTime() {
currentTime = clock() - currentTime;
double time_spended = ((double)currentTime)/CLOCKS_PER_SEC;
return time_spended;
}
void ShowResult(sort_measure_t data2) {
sort_measure_t* data = &data2;
printf("\
ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ\n\
º Nume º %s \n\
ÌÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ\n\
º Iteratii º %d \n\
ÌÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ\n\
º Permutari º %d \n\
ÌÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ\n\
º Timpul º %.6f sec \n\
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ\n",
data->sort_name,
data->iterations,
data->permutations,
data->time_spended
);
printf("\n");
}
void GenerateRandom(int num){
n = num;
memset(rawData, 0, sizeof(rawData));
srand(time(NULL));
int i = 0;
num++;
while(--num){
rawData[i++] = rand();
}
}
int cmpfunc (const void * a, const void * b)
{
return ( *(int*)a - *(int*)b );
}

5
sort_measure_t native_qsort() {
sort_measure_t data = {
.iterations = -1,
.permutations = -1,
.sort_name = "Native qsort",
.time_spended = 0.0d
};
CopyRawToBeSorted();
StartTime();

qsort(need, n, sizeof(need[0]), cmpfunc);

data.time_spended = StopTime();
return data;
}
sort_measure_t quicksort(int st, int dr) {
sort_measure_t data = {
.iterations = 0,
.permutations = 0,
.sort_name = "Quick Sort",
.time_spended = 0.0d
};
CopyRawToBeSorted();
StartTime();

quicksort_raw(st, dr, &data);

data.time_spended = StopTime();
return data;

}
void quicksort_raw(int st, int dr, sort_measure_t* data) {
int i,j,m,aux;
i=st;
j=dr;
m=(st+dr)/2;
do {
data->iterations++;
while(i<=dr && need[i]<need[m]) {
data->iterations++;
i++;
}
while(j>=st && need[j]>need[m]){
data->iterations++;
j--;
}
if (i<=j){
Swap(&need[j], &need[i]);
data->permutations++;
i++;
j--;
}

6
 } while(i<=j);
if (st<j) {
quicksort_raw(st,j, data);
}
if(dr>i) {
quicksort_raw(i,dr, data);
}
}
void main(){
int st, dr;
int optiune=0;
do{
system("CLS");
printf("\
ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»\n\
º PROGRAM MENU º\n\
ÌÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͺ\n\
º 1. Citirea elementelor din fisier º\n\
º 2. Introducerea numarului de elemente aleatoare º\n\
º 3. Sortarea elementelor º\n\
º 4. Afisarea elementelor º\n\
º 5. Afisarea elementelor sortate º\n\
º 6. Salavare elementelor sortate in ordine crescatoare º\n\
º 7. Salavare elementelor sortate in ordine descrescatoare º\n\
º 0. Iesire º\n\
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ\n",185);
printf("\n Alegeti optiunea: ");
scanf("%d",&optiune);
switch (optiune){
case 1:{
char d[40];
printf(" Filename: ");
scanf(" %s", d);
ReadDataFromFile(d);
system("pause");
break;
}
case 2:{
int num;
printf(" n = ");
scanf(" %d", &num);
GenerateRandom(num);
system("pause");
break;
}
case 3:{
ShowResult(quicksort(0, n-1));
ShowResult(native_qsort());
system("pause");
break;
}
case 4:

7
 ShowRaw(rawData);
system("pause");
break;
case 5:
ShowRaw(need);
system("pause");
break;
case 6:{
Write("ascending", need);
system("pause");
break;
}
case 7:{
WriteRev("descending", need);
system("pause");
break;
}
case 0:{
return 0;
}
default:{
printf(" Optiunea nu exista!\n");
break;
}
}
}
while(optiune!=0);
getch();
return 0;
}
void test() {
ReadDataFromFile("data");
ShowRaw(rawData);
sort_measure_t data = quicksort(0, n-1);
ShowResult(data);
ShowRaw(need);
}

8
Screen Shot-uri:

Fig 1. Meniul programului

Fig 2. Introducerea elementelor random de la tastatura n = 10000

9
 Fig 3. Sortarea elementelor

Fig 4. Introducerea elementelor random de la tastatura n = 20000

Fig 5. Sortarea elementelor

10
 Fig 6. Introducerea elementelor random de la tastatura n = 40000

Fig 7. Sortarea elementelor

Concluzii:
Quicksort este un celebru algoritm de sortare, de obicei quicksort este mai rapid decit ceilalti
algoritmi de sortare , puteti vedea mai sus in screen shot-uri ca efectueaza putine permutari si
iteratii intr-un interval de timp foarte scurt. Quicksort efectueaza sortarea bazandu-se pe o
anumita strategie. Astfel, el imparte lista de sortat în două subliste mai usor de sortat

Bibliografie:

1. Conspectul prelegerilor cursului Programarea Calculatoarelor. Lector dr., conf. univ.

M.Kulev.
2. http://www.cprogramming.com/tutorial/c/lesson15.html
3. http://stackoverflow.com/questions/5636070/zero-an-array-in-c-code

11