Sunteți pe pagina 1din 7

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

D.Cucu

A verificat:
dr., conf.univ.

M. Kulev

Chiinu 2016

Lucrarea de laborator nr.6


Tema: Analiza emperic a algoritmilor de sortare i de cutare
Scopul lucrrii: 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: qsort()


Quicksort efectueaz sortarea bazndu-se pe o strategie divide et impera. Astfel, el mparte lista de sortat n
dou subliste mai uor de sortat. Paii algoritmului sunt:
1. Se alege un element al listei, denumit pivot
2. Se reordoneaz lista astfel nct toate elementele mai mici dect pivotul s fie plasate naintea
pivotului i toate elementele mai mari s fie dup pivot. Dup aceast partiionare, pivotul se afl n
poziia sa final.
3. Se sorteaz recursiv sublista de elemente mai mici dect pivotul i sublista de elemente mai mari dect
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-Cpentru-incepatori-vol-1

http://devcentral.iftech.com/learning/tutorials/c-cpp/c