Ministerul Educaţiei al Republicii Moldova

Universitatea de Stat din Moldova

Departamentul Informatică

Lucrare de laborator nr.2

La disciplina Algoritmi, Structuri de date si

Complexitate

Tema:Metode de sortare

Efectuat de : Tintaru Valeria, gr.I1801

Verificat de: Opinca Carolina, conf., univ.

Chişinău, 2020

1
Sarcina laboratorului:

Să se creeze un fişier textual care conţine cel puţin 50 de înregistrări, cu cel puţin 5
câmpuri şi are cel puţin 2 tipuri de date, iar câmpul cheie trebuie să fie unic şi
neordonat.
Să fie realizat un program în C++, în care sunt implementate câteva metode de sortare (cel
puţin două) în tabele neordonate după câmpul cheie din fişierul textual creat anterior.
Pentru fiecare metodă de sortare de analizat complexitatea teoretică şi practică.
Să se afişeze următoarele date:
- Estimarea teoretică a complexităţii;
- Număr de comparaţii;
- Număr de permutări;
- Timpul de execuţie al fiecărui algoritm de sortare.
De descris algoritmul metodelor de căutare pe paşi.

Să se implementeze cîteva metode de sortare și să se efectueze sortarea după cheie din fișierul
textual, iar pentru fiecare metodă de sortare să se efectueze urmatoarele:
- Metoda inserției;
- Metoda selecției;
- Metoda rapida;
- Metoda Shell;
- Metoda Heapsort.

Sortarea prin insertie

Considerãm elementele A[1]...A[i-1] fiind sortate, inserãm elementul A[i] în locul ce îi revine. Fiind
dat o tabelã A cu N elemente nesortate, parcurgem tabela si le inserãm fiecare element în locul
propriu între celelalte elemente considerate sortate. Pentru fiecare i = 2..N , elementele A[1]…A[i] sunt
sortate prin inserarea lui A[i] între lista elementelor sortate: A[1]…A[i-1]. Elementele aflate în stânga
indexului sunt în ordine sortatã dar nu sunt în pozitia lor finalã. Tabela este sortatã complect când
indexul ajunge la capãtul drept al tabelei.

Complexitatea teoretica de sortare este O(n2).

Sortare rapida:

Cazul mediu : O(N log N)

Cazul cel mai nefavorabil : O(N^2)
Memorie folosita : O(log N)
Stabil : DA
Sortare descrescatoare : while(vector[min] > mijl) min++;
while(vector[max] < mijl) max--;
Sortare crescatoare : while(vector[min] < mijl) min++;
while(vector[max] > mijl) max--;

2
Quicksort este un celebru algoritm de sortare, dezvoltat de C. A. R. Hoare și care, în medie,
efectuează θ(nlog n) comparații pentru a sorta nelemente. În cazul cel mai rău,
efectuează O(n2) comparații. De obicei, în practică, quicksort este mai rapid decât ceilalți algoritmi de
sortare dee complexitate  θ(nlog n) deoarece bucla sa interioară are implementări eficiente pe
majoritatea arhitecturilor și, în plus, în majoritatea implementărilor practice se pot lua, la proiectare,
decizii ce ajută la evitarea cazului când complexitatea algoritmului este de O(n2)

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ă.

Listingul programului:

#include<iostream>
#include<fstream>
#include<string>
#include<conio.h>
#include<vector>
#include<iomanip>
#include <ctime>
#include<algorithm>
#include<cmath>

using namespace std;

class STUDENT
{ public:
int id;
string nume;
string prenume;
string specialitatea;
int anul_nasterii;
public:
friend int operator < (const STUDENT&, const STUDENT&);
friend int operator > (const STUDENT&, const STUDENT&);
friend int operator < (const STUDENT&, const int&);
friend int operator > (const STUDENT&, const int&);
friend int operator == (const STUDENT&, const int&);

3
};

int operator > (const STUDENT& ob1, const STUDENT& ob2)

{
return (ob1.id > ob2.id);
}

int operator < (const STUDENT& ob1, const STUDENT& ob2)

{
return (ob1.id < ob2.id);
}
int operator < (const STUDENT& ob1, const int& ob2)
{
return (ob1.id < ob2);
}
int operator > (const STUDENT& ob1, const int& ob2)
{
return (ob1.id > ob2);
}

int operator == (const STUDENT& ob1, const int& ob2)

{
return (ob1.id == ob2);
}
//************************************
template<class Type>
class table
{
public:

vector<Type> V;
double inceput;
double sfirsit;
int comparatii;
int interschimbari;
public:
table();

void setInceput() { inceput=(double)clock(); }

void setSfirsit() { sfirsit=(double)clock(); }
void Timp();

int getSize() { return V.size(); }

int getComp() { return comparatii; }
int getInter() { return interschimbari; }

void setComp(int a) { comparatii=a; }

void setInter(int a) { interschimbari=a; }

void swap(int i, int j);

void print();

4
 void Sort_bule();

void quicksort(int &stinga, int &dreapta);

void insertSort(int n);

void insert(int n);

void selectSort();

};
//************************************
template<class Type>
table<Type>::table()
{
ifstream file("STUDENT.txt");

if(file.fail())
{
cerr<<"Eroare la deschiderea fisierului!"<<endl;
getch();
exit(1);
}

STUDENT* value=new STUDENT;

while(!file.eof())
{
file>>value->id;
file>>value->nume;
file>>value->prenume;
file>>value->specialitatea;
file>>value->anul_nasterii;

this->V.push_back(*value);
}//while
comparatii=0;
interschimbari=0;
file.close();

}
//**********************************************
template<class Type>
void table<Type>::Timp()
{
cout<<"Timpul de cautare este: "<<(double)(sfirsit -
inceput)/(double)CLOCKS_PER_SEC
<< " milisecunde" << endl;
}
//***********************************************
template<class Type>
void table<Type>::print()
{

5
 cout<<endl<<setw(50)<<"AFISAREA DATELOR"<<endl;

cout<<setw(5)<<"Id"<<setw(15)<<"nume"<<setw(20)<<"prenume"<<setw(17)<<"specialitat
ea"<<setw(20)<<"anul_nasterii"<<endl<<endl;
for(int i=0;i<this->V.size();i++)
{
cout<<setw(5)<<this->V.at(i).id<<setw(15)
<<this->V.at(i).nume<<setw(17)
<<this->V.at(i).prenume<<setw(17)
<<this->V.at(i).specialitatea<<setw(17)
<<this->V.at(i).anul_nasterii<<endl;
}
cout<<endl<<"Dimensiunea tabelului n= "<<V.size()<<endl;

}
//**********************************************
template<class Type>
void table<Type>::swap(int i, int j)
{
Type row;
row=V.at(i);
V.at(i)=V.at(j);
V.at(j)=row;
}
//**********************************************
template<class Type>
void table<Type>::Sort_bule()
{ setInceput();
bool invers;
do
{
invers=false;
for(int i=0;i<V.size()-1;i++)
{ comparatii++;
if(V.at(i).id>V.at(i+1).id)
{
interschimbari++;
swap(i, i+1);
invers=true;
} }
} while(invers);
setSfirsit();
cout<<"Numarul de comparatii: "<<comparatii<<endl;
cout<<"Numarul de interschimbari: "<<interschimbari<<endl;

}
//************************************************
template<class Type>
void table<Type>::insert(int n)
{
for(int i=n-1;i>0;i--)
{ comparatii++;

6
 if(V.at(i).id<V.at(i-1).id) { interschimbari++;
swap(i,i-1); }
}

template<class Type>
void table<Type>::insertSort(int n)
{
if(n>1)
{
insertSort(n-1);
insert(n);
}
}

//************************************************
template<class Type>
void table<Type>::selectSort()
{
int i,j,imax;
setInceput();
for(i=V.size()-1;i>0;i--)
{
imax=i;
for(j=0;j<i;j++)
{
if(V.at(j).id > V.at(imax).id) imax=j;
comparatii++;
}
interschimbari++;
swap(i,imax);
}
setSfirsit();
}

//************************************************
template<class Type>
void table<Type>::quicksort(int &stinga, int &dreapta)
{
if(dreapta==V.size() - 1)
{
setInceput();
}
if(stinga < dreapta)
{
Type pivot=V.at(stinga);
int st=stinga - 1;
int dr=dreapta + 1;
while(1)
{
while(V.at(--dr) > pivot)

7
 {
++comparatii;
}
while(V.at(++st) < pivot)
{
++comparatii;
}
if(st >= dr) break;
swap(dr, st);
++interschimbari;
}//while
int k=dr+1;
quicksort(stinga,dr);
quicksort(k,dreapta);
}

}
//************************************************

int main() {
table<STUDENT>* unu=new table<STUDENT>();
unu->print();
cout<<"****************************************"<<endl;
cout<<" Sortarea prin metoda bulelor:"<<endl;
unu->Sort_bule();
unu->Timp();
// unu->print();
cout<<"****************************************"<<endl;
cout<<" Sortarea rapida:"<<endl;
table<STUDENT>* doi=new table<STUDENT>();
int j=doi->getSize()-1, k=0;
doi->quicksort(k,j);
doi->setSfirsit();
//doi->print();

cout<<"Numarul de comparatii: "<<doi->getComp()<<endl;

cout<<"Numarul de interschimbari: "<<doi->getInter()<<endl;
doi->Timp();
cout<<"****************************************"<<endl;
cout<<" Sortarea prin insertie:"<<endl;
table<STUDENT>* trei=new table<STUDENT>();
trei->setInceput();
trei->insertSort(trei->getSize());
trei->setSfirsit();

//trei->print();
cout<<"Numarul de comparatii: "<<trei->getComp()<<endl;
cout<<"Numarul de interschimbari: "<<trei->getInter()<<endl;
trei->Timp();
cout<<"****************************************"<<endl;
cout<<" Sortarea prin selectie:"<<endl;
table<STUDENT>* patru=new table<STUDENT>();

8
 patru->selectSort();
//patru->print();
cout<<"Numarul de comparatii: "<<patru->getComp()<<endl;
cout<<"Numarul de interschimbari: "<<patru->getInter()<<endl;
patru->Timp();
cout<<"****************************************"<<endl;

return 1;

}
Continutul fișierului student.txt

9
Rezultatul:

10
Concluzii

Sortarea reprezintă una dintre cele mai utilizate metode de programare. Sortarea este folosită în
mareamajoritate bazelor de date mari, dar și în secevențe mici de înregistrări. Are utilizări de la
domenii precum matematica (statistica matematica), pînă la limbi (realizarea unor dictionare).
În cadrul acestei lucrări de laborator am analizat 4 algoritmi de sortare : metoda bulelor, metoda
rapidă, prin inserție și prin selecție. Am analizat acești algoritmi din punct de vedere a complexitații și
a duratei timpului necesar execuției. Cel mai lent algoritm din cele 4 este metoda bulelor.

La moment sunt elaborați mulți algoritmi de sortare, și deja în dependență de necesitate a

problemei (numărul de inregistrări, timpul necesar, memoria disponibilă) se va alege unul optim.

11
i