Ministerul Educaiei al Republicii Moldova

Universitatea Tehnic a Moldovei

Departametul Ingineria software i automatic

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

A efectuat:
st. gr. AI-161 V.Platon

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

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) cu afiarea meniului cu urmtoarele obiuni:

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 cresctor
4. Tabloul sortat invers (descresctor)
5. Analiza emperic a 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 (mutri), comprarea rezultatelor obinute i aranjate n
tabela i formularea concluziilor.
Varianta 4: Sortarea prin selectie si interschimbare

Mersul lucrrii:
Noiuni 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 poziii nesortate (schimbarea nu este
necesar dac elementul minim este deja n aceast poziie)
3. Acum, sortam coada listei, nu luind n considerare elemente sortate deja

QickSort
Quick Sort este unul dintre cei mai rapizi i mai utilizai algoritmi de sortare pn n acest
moment, bazndu-se pe tehnica "Divide et Impera".
Sortarea rapid se realizeaz ntr-o funcie care, aplicat unui ir de numere, poziioneaz un
element din ir, pivot, pe poziia final, pe care se va afla acesta n irul sortat, i deplaseaz
elementele din ir mai mici dect acesta n faa sa, iar pe cele mai mari dup el. Procedeul se reia
pentru fiecare din cele dou subiruri care au rmas neordonate.
Algoritmul se poate descrie n urmtoarele etape:
Etapa Divide: Vectorul x, format din elementele aflate ntre indicii i i j, notat n continuare
x[i..j], este mprit n doi subvectori x[i ..m] i x[m+1 ..j], fiecaresubvector avnd cel puin un
element i fiecare element din primul subvector fiind mai mic sau egal dect oricare element din
cel de-al doilea subvector.
Etapa Impera: Cele dou pri sunt sortate apelnd recursiv, pn cnd se ajunge
la subvectori formai dintr-un singur element.
Combinarea: Avnd n vedere c fiecare subvector este sortat i c cel mai mare element
din subvectorul stng este mai mic dect cel mai mic element dinsubvectorul drept, atunci
ntregul vector va fi sortat.

Cea mai important etap este cea de partiionare. Exist mai multe moduri n care se poate
mpri vectorul, dar urmtorul algoritm, inventat de R. Sedgevvick, pare a fi cel mai bun: se
pornete de la ambele capete, folosind doi indicatori, i pentru partea stng i j pentru partea
dreapt, cutndu-se elementele care ar trebui s fie n cealalt parte; n momentul n care se
gsesc 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

Caracteristica:
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.