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. SI-151 D.Cucu

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

Chişinău 2016
 Lucrarea de laborator nr.6

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

Scopul lucrării: 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: qsort()

Quicksort efectuează sortarea bazându-se pe o strategie divide et impera. Astfel, el împarte lista de sortat în
două subliste mai ușor de sortat. Pașii algoritmului sunt:

1. Se alege un element al listei, denumit pivot

2. Se reordonează lista astfel încât toate elementele mai mici decât pivotul să fie plasate înaintea
pivotului și toate elementele mai mari să fie după pivot. După această partiționare, pivotul se află în
poziția sa finală.
3. Se sortează recursiv sublista de elemente mai mici decât pivotul și sublista de elemente mai mari decât
pivotul.

O listă de dimensiune 0 sau 1 este considerată sortată.

Pseudocod QuickSort:

procedura QUICKSORT(A, inf, sup) este

| i← inf
| j← sup
| x← A[(i+j) div 2]
| repeta
| | cat timp (i<sup)/\ (A[i]<x) executa i← i+1
| | cat timp (j>inf) /\ (A[j]>x) executa j← j-1
| | daca i <=j atunci
| | | t← A[i]; A[i]← A[j]; A(j)← t
| | | i← i+1; j← j-1
| | |___▄
| pana cand (i>j)
| daca (inf<j) atunci QUICKSORT(A, inf, j)
| daca (i<sup) atunci QUICKSORT(A, i, sup)
|___▄

O posibilă implementare a algoritmului, in limbajul C sub forma unei funcții, este redată mai jos:

void QUICKSORT(int inf, int sup) {

int x, i, j, t;
i = inf;
j = sup;
x = A[(i + j) / 2];
do {
while ( (i < sup) && (A[i] < x) ) i++;
while ( (j > inf) &&(A[j] > x) ) j--;
if ( i<= j ) {
t = A[i];
A[i] = A[j];
A[j] = t;
i++;
j--;
}
} while ( i <= j );
if ( inf < j ) QUICKSORT(inf, j);
if ( i < sup ) QUICKSORT(i, sup);
}

Codul programului
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

long qsortC(int *a,int n)

{
int i,j,pas,aux;
long nr_i = 0;

for(pas=n/2; pas>0; pas/=2)

for(i=pas; i<n; i++)
for(j=i-pas; j>=0 && a[j]>a[j+pas]; j-=pas)
{
aux = a[j];
a[j] = a[j+pas];
a[j+pas] = aux;
nr_i++;
 }
return nr_i;
}

long qsortD(int *a,int n)

{
int i,j,pas,aux;
long nr_i = 0;

for(pas=n/2; pas>0; pas/=2)

for(i=pas; i<n; i++)
for(j=i-pas; j>=0 && a[j]<a[j+pas]; j-=pas)
{
aux = a[j];
a[j] = a[j+pas];
a[j+pas] = aux;
nr_i++;
}
return nr_i;
}

int main()
{
int dimension, m = 1,comand;
float times;
int *vector = NULL;

while(1)
{
while(m)
{
m = 0;
system("cls"); fflush(stdin);
printf("Introduceti marimea vectorului (numarul de elemente) : ");
scanf("%d",&dimension);
vector = (int*)malloc(dimension * sizeof(int));
if(!vector)
{
printf("\nMemoria nu a fost alocata! Incercati din nou.\a\n");
m = 1;
}
}
system("cls"); fflush(stdin);
printf("Meniu sortare :\n\n");
printf("[ 1 ] In ordine crescatoare\n");
printf("[ 2 ] In ordine descrescatoare\n\n");
printf("[ 0 ] Exit\n\n");
printf("Comand >> ");
scanf("%d",&comand); system("cls");
switch(comand)
{
case 0 : if(vector) free(vector); return 0; break;
case 1 :
do{
system("cls"); fflush(stdin);
printf("Ce sortam??\n");
printf("[ 1 ] Un tablou deja sortat\n");
printf("[ 2 ] Un tablou aleatoriu\n");
printf("[ 3 ] Un tablou sortat invers\n\n");
printf("[ 0 ] Inapoi?\n\n");
printf("Comand >> ");
scanf("%d",&comand); system("cls");
switch(comand)
{
case 0 : break;
case 1 :
for(int i=0; i<dimension; i++)
{
vector[i] = i;
}
times = clock();
printf("Sortarea sa efectuat in %f secunde si sau produs %d schimbari\n",
(clock()-times)/CLOCKS_PER_SECqsort(vector,dimension));
system("pause");
break;
case 2 :
srand(time(NULL));
for(int i=0; i<dimension; i++)
{
vector[i] = rand() % 100;
}
times = clock();
printf("Sortarea sa efectuat in %f secunde si sau produs %d schimbari\n",
(clock()-times)/CLOCKS_PER_SEC,qsortC(vector,dimension));
system("pause");
break;
case 3 :
for(int i=0; i<dimension; i++)
{
vector[i] = dimension - i;
}
times = clock();
printf("Sortarea sa efectuat in %f secunde si sau produs %d schimbari\n",
(clock()-times)/CLOCKS_PER_SEC,qsortC(vector,dimension));
system("pause"); break;
default : printf("\aAti introdus o comanda gresita\n"); break;
}
}while(comand);
break;
case 2 :
do{
system("cls"); fflush(stdin);
printf("Ce sortam??\n");
 printf("[ 1 ] Un tablou deja sortat\n");
printf("[ 2 ] Un tablou aleatoriu\n");
printf("[ 3 ] Un tablou sortat invers\n\n");
printf("[ 0 ] Inapoi?\n\n");
printf("Comand >> ");
scanf("%d",&comand); system("cls");
switch(comand)
{
case 0 : break;
case 1 :
for(int i=0; i<dimension; i++)
{
vector[i] = dimension - i;
}
times = clock();
printf("Sortarea sa efectuat in %f secunde si sau produs %d schimbari\n",
(clock()-times)/CLOCKS_PER_SEC,qsortD(vector,dimension));
system("pause"); break;
case 2 :
srand(time(NULL));
for(int i=0; i<dimension; i++)
{
vector[i] = rand() % 100;
}
times = clock();
printf("Sortarea sa efectuat in %f secunde si sau produs %d schimbari\n",
(clock()-times)/CLOCKS_PER_SEC,qsortD(vector,dimension));
system("pause");break;
case 3 :
for(int i=0; i<dimension; i++)
{
vector[i] = i;
}
times = clock();
printf("Sortarea sa efectuat in %f secunde si sau produs %d schimbari\n",
(clock()-times)/CLOCKS_PER_SEC,qsortD(vector,dimension));
system("pause");break;
default : printf("\aAti introdus o comanda gresita\n"); break;
}
}while(comand); break;

default : printf("\aAti introdus o comanda gresita\n"); break;

}
system("pause");
}
return 0;
}
 Rezultatele obtinute

Concluzii: In urma acestei lucrari de laborator am ajuns la ideia ca shell sort este un
algoritm de sortare bun, insa nui asa de rapid ca qsort. Pentru sirurile deja aranjate se face
0 (zero) mutari, ceia ce ii un rezultat bun pentru viteza efectuarii. Inca un plus pentru
acest algoritm este ca nu necesita memorie adaugatoare fata de qsort.

Bibliografie:
 http://programmersclub.ru/01/
 TOTUL DESPRE C SI C++ (MANUALUL FUNDAMENTAL DE
PROGRAMARE IN C SI C++)[RO][Kris Jamsa][Lars Kland]
 Limbajul C pentru clasa a-IX-a
 http://www.scribd.com/doc/41293824/Negrescu-Liviu-Limbajele-C-si-C-
pentru-incepatori-vol-1
 http://devcentral.iftech.com/learning/tutorials/c-cpp/c