Sunteți pe pagina 1din 10

Ministerul Educaiei 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. AI-161 D.Dolgan

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

Chiinu-2017
Lucrarea de laborator nr.6

Tema: Analiza emperic a algoritmilor de sortare i de cutare

Scopul lucrarii: Obinerea 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 afiarea meniului cu urmtoarele obiuni:

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 cresctor

4. Tablou sortat invers (descresctor)

5. Analiza algoritmului funciei standard de sortare qsort() sau funciei standard de cutare
bsearch()

Analiza emperic a algoritmului const n: determinarea timpului de rulare, numrului de


comprri, numrului de interschimbri (muri), comprarea rezultatelor obinute i aranjate n
tabela i formularea concluziilor.

Varianta 10: Sortarea qsort

Noiuni teoretice

Uneori analiza teoretic a eficienei este dificil; n aceste cazuri poate fi util analiza empiric.
Analiza empiric poate fi utilizat pentru:
o Formularea unei ipoteze iniiale privind eficiena algoritmului
o Compararea eficienei a mai multor algoritmi destinai rezolvrii aceleiai probleme
o Analiza eficienei unei implementri a algoritmului (pe o anumit maina)
o Verificarea acurateii unei afirmaii privind eficiena algoritmului
Structura general a analizei empirice
1. Se stabilete scopul analizei
2. Se alege o msur a eficienei (de exemplu, numrul de execuii ale unor operaii sau timpul
necesar execuiei unor pai 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
instruciunile necesare efecturii analizei (contoare, funcii de nregistrare a timpului necesar
execuiei etc)
5. Se genereaz datele de intrare
6. Se execut programul pentru fiecare dat de intrare i se nregistreaz rezultatele
7. Se analizeaz rezultatele obinut

1
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;
printf(" Lista elementelor\n");

2
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 );
}
sort_measure_t native_qsort() {

3
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--;
}
} while(i<=j);

4
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:
ShowRaw(rawData);

5
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);
}

Functionarea programului:

Fig 1. Meniul programului

6
Fig 2. Introducerea elementelor random de la tastatura n = 15000

Fig 3. Sortarea elementelor

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

7
Fig 5. Sortarea elementelor

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

Fig 7. Sortarea elementelor

8
Concluzie:
Avantaje:
Quick Sort este unul dintre cei mai rapizi si mai utilizati algoritmi de sortare pana
in acest moment, timpul de executie este foarte rapid. Este mai rapida decit orice
metoda de sortare simpla, se executa bine pentru fisiere sau tabele mari, dar
ineficient pentru cele mici.
Dezavantaje: Exista implementat in libraria stdlib.h, dar prezinta bug-uri asa ca
se recomanda implementarea lui de mana.
Memoria folosita, intelegerea si implementarea algoritmului. Necesita n jur de N 2
de operatii n caz nefavorabil. Este fragil, o simpla greseal n implementare poate
cauza o executare gresita pentru anumite fisiere

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