Ministerul Educaţiei al Republicii Moldova

Universitatea Tehnică a Moldovei

RAPORT
Lucrarea de laborator nr. 6
la Structuri de date și algoritmi

A efectuat:
st. gr. CR-182 C.Conea

A verificat:
S.Munteanu

Chişinău -2019
 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ă) cu afișarea meniului cu următoarele obțiuni:

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

2. Tabloul cu valori aleatoare pentru trei numere n1, n2, n3 de elemente mari
(10000<n1<n2=10*n1<n3=10*n2)
3. Tabloul sortat crescător
4. Tabloul sortat invers (descrescător)
5. Analiza emperică a 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 (mutări), compărarea rezultatelor obținute și aranjate în
tabela și formularea concluziilor.
Varianta 3: Sortarea prin selectie si interschimbare

Mersul lucrării:
Noţiuni principale din teorie şi metode folosite:
Sortare prin selectie si interschimbare
Sortare prin selectie (Selection Sort) – este un algoritm de sortare. Poate fi cum stabil atit si
nestabil. La un masiv cu n elemente are timp de executie, in cel mai rau caz O(n2 ), fiindca
comparari se efectueaza in mod continui. Sortare prin selectie este numita patratica.

Algoritmul
Pasii:
1. Gasim idiciu elementului minimal
2. Să schimbe această valoare cu valoarea primelor poziții nesortate (schimbarea nu este
necesară dacă elementul minim este deja în această poziție)
3. Acum, sortam coada listei, nu luind în considerare elemente sortate deja

QickSort
     Quick Sort este unul dintre cei mai rapizi şi mai utilizaţi algoritmi de sortare până în acest
moment, bazându-se pe tehnica  "Divide et Impera".
    Sortarea rapidă se realizează într-o funcţie care, aplicată unui şir de numere, poziţionează un
element din şir, pivot, pe poziţia finală, pe care se va afla acesta în şirul sortat, şi deplasează
elementele din şir mai mici decât acesta în faţa sa, iar pe cele mai mari după el. Procedeul se reia
pentru fiecare din cele două subşiruri care au rămas neordonate.
      
Algoritmul se poate descrie în următoarele etape:
Etapa Divide:  Vectorul x, format din elementele aflate între indicii i şi j, notat în continuare
x[i..j], este împărţit în doi subvectori x[i ..m] şi x[m+1 ..j], fiecaresubvector având cel puţin un
element şi fiecare element din primul subvector fiind mai mic sau egal decât oricare element din
cel de-al doilea subvector.
Etapa Impera: Cele două părţi sunt sortate apelând recursiv, până când se ajunge
la subvectori formaţi dintr-un singur element.
Combinarea: Având în vedere că fiecare subvector este sortat şi că cel mai mare element
din subvectorul stâng este mai mic decât cel mai mic element dinsubvectorul drept, atunci
întregul vector va fi sortat.
 
      Cea mai importantă etapă este cea de partiţionare. Există mai multe moduri în care se poate
împărţi vectorul, dar următorul algoritm, inventat de R. Sedgevvick, pare a fi cel mai bun: se
porneşte de la ambele capete, folosind doi indicatori, i pentru partea stângă şi j pentru partea
dreaptă, căutându-se elementele care ar trebui să fie în cealaltă parte; în momentul în care se
găsesc două elemente care nu sunt în ordinea dorită şi dacă iinterschimbă şi se continuă
algoritmul; altfel, algoritmul întoarce valoarea lui j; element de referinţă se consideră ca fiind
primul element din vector.
 
Listingul programului:
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <time.h>

//---------------------------------------------------------------------------
int int_cmp(const void *a, const void *b)
{
const int *ia = (const int *)a; // casting pointer types
const int *ib = (const int *)b;
return *ia - *ib;
}

int selection_sort( int *array,int n)

{ int c, d, position, swap;
long int com,in;

clock_t tic = clock();com=0;

in=0;
for ( c = 0 ; c < ( n - 1 ) ; c++ )
{
position = c;

for ( d = c + 1 ; d < n ; d++ )

{com++;
if ( array[position] > array[d] )
position = d;
}
if ( position != c )
{
swap = array[c];
array[c] = array[position];
array[position] = swap;
in++;
}
}
clock_t toc = clock();
printf("\nTimp: %f sec\n", (double)(toc - tic) / CLOCKS_PER_SEC);
printf("Intershimbari=%d;\nComparari=%d",in,com);
return 1;
}
void read_array(int *A,int n)
{
int i;
 printf("\nIntroduceti elemente\n");
for (i=0;i<n;i++)
{
printf("\Element[%d]=",i+1);
scanf("%d",&A[i]);
printf("\n");
}
}
void show_array(int *A,int n)
{
int i;

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

}
}
int main()
{
int *A;
int n,i, flag;
while(1)
{
system("cls");
printf("\t\t\tMENU\n");
printf("1) Introducerea datelor de utilizator.\n");
printf("2) Tabloul cu valori aleatoare pentru trei numere \n");
printf("3) Compararea cu qsort\n");
printf("0) Iesire din program.\n Alegeti optiune: ");
scanf("%d", &flag);
switch(flag)
{
case 4:
printf("Introduceti numarul de elemente: ");
scanf("%d",&n);
A=(int*)malloc(n*sizeof(*A));
for(i=0;i<n;i++) A[i]=i;
selection_sort(A,n);
clock_t tic = clock();
qsort(A, n, sizeof(int), int_cmp);
clock_t toc = clock();
printf("\nTime Qsort: %f sec\n", (double)(toc - tic) / CLOCKS_PER_SEC);

// show_array(A,n);
getch();
break;
case 1: system("cls");
printf("Introduceti numarul de elemente: ");
scanf("%d",&n);
A=(int*)malloc(n*sizeof(*A));
read_array(A,n);

selection_sort(A,n);
printf("\nTabloul Sortat prin selectie\n");
show_array(A,n);
getch(); break;

case 2:
system("cls");
printf("Introduceti numarul de elemente pentru tablou: ");
scanf("%d",&n);

printf("\n--------------------------------------------------------------\n");
printf("\nTabloul cu %d elemente",n);
A=(int*)malloc(n*sizeof(*A));
int n2,n3,i;
for (i=0;i<n;i++)
{
A[i]=rand()%20000-8921;
 }
selection_sort(A,n);
n2=0;
n2=n*10;

printf("\n--------------------------------------------------------------\n");
printf("\nTabloul cu %d elemente",n2);
A=(int*)malloc(n2*sizeof(*A));
for (i=0;i<n2;i++)
{
A[i]=rand()%200000-8921;
}
selection_sort(A,n2);
n3=n2*10;

printf("\n--------------------------------------------------------------\n");
printf("\nTabloul cu %d elemente",n3);
A=(int*)malloc(n3*sizeof(*A));
for (i=0;i<n3;i++)
{
A[i]=rand()%200000-8921;
}
selection_sort(A,n3);

printf("\n--------------------------------------------------------------\n");
getch();
break;

case 3:
printf("Comparare cu Qsort");
printf("\nIntrodu numarul de elemente: ");
scanf("%d",&n);

A=(int*)malloc(n*sizeof(*A));
int *B;
B = (int *)malloc(n*sizeof(*B));
for(i=0;i<n;i++)
{
A[i]=rand()%10000-723;
B[i]=A[i];
}int ch;
printf("\n De afisat tablou nesortat?: ");
scanf("%d",&ch);
if(ch==1)
{ printf("\nTabloul nesortat: ");
show_array(A,n);

}
selection_sort(A,n);
tic = clock();
qsort(B, n, sizeof(int), int_cmp);
toc = clock();
printf("\nTime Qsort: %f sec\n", (double)(toc - tic) / CLOCKS_PER_SEC);
getch();
break;

case 0: exit(1); break;

}

}
}
Verificarea programului:
Tabloul cu valori aleatoare pentru trei numere

Numar de elemente(n) 1000 10000 100000

Timp 0.003 s 0.213 s 19.267 s
Interschimbari 994 9994 99984
Comparari 4999500 49995000 704982704
O(n2 ) 1000000 100000000 10000000000
Marimea 1,95 kB 18.76 kB 195.65 kB

Timp
25

20

15
Timp

10

0
1000 10000 100000
Comparare cu qsort pentru 10000 de elemente

Comparare cu qsort pentru 100000 de elemente

Algoritmul Selectie si intershimbare QuickSort

Elemente 10000 100000 10000 100000
Timp 0.206 19.061 0.003 0.025
Concluzii:
In acest laborator am facut analiza emperica a algoritmului sortarii prin
selectie si interchimbare, si am comparat algoritmul acest cu algortim de sortare
rapide qsort.
Am observat ca numarul de comparari la algoritmul de sortare si selectie este
stabilit si depinde de numarul de elemente.
Sortare rapida este mai efecienta in comaratie cu sortare prin selectie in 60
de ori. Cu cresterea numarului de elemente, efecienta algorimului de sortatre prin
selectie scade consecutiv.