Ministerul Educaţiei și Cercetării al Republicii Moldova

Universitatea Tehnică a Moldovei

Facultatea Calculatoare, Informatică și Microelectronică

RAPORT
Lucrarea de laborator nr.2
la Analiza și Proiectarea Algoritmilor
Tema: Analiza algoritmilor de sortare

A efectuat:
st. gr. TI-224 Russu Iulia

A verificat:
asist. univ. Astafi Valentina

Chişinău – 2023
 Cuprins:

Considerații teoretice.........................................................................................................................................................3
Mersul lucrării....................................................................................................................................................................3
Merge sort......................................................................................................................................................................4
Quick sort.......................................................................................................................................................................5
Bubble sort.....................................................................................................................................................................5
Proprietățile datelor de intrare în raport cu care se face analiza........................................................................................6
Analiza empirică a algoritmilor.........................................................................................................................................6
Metrica folosită pentru compararea algoritmilor...........................................................................................................6
Concluzie........................................................................................................................................................................... 7
Anexa 1. Codul sursă.........................................................................................................................................................8
Exemplu de afișare.......................................................................................................................................................13

2
 Lucrare de laborator nr. 1

Tema: Analiza algoritmilor de sortare

Sarcina lucrării:
1. Implementați algorimtii propuși într-un limbaj de programare.
2. Stabiliți proprietățile datelor de intrare în raport cu care se face analiza.
3. Alegeți metrica pentru compararea algoritmilor.
4. Efectuați analiza empirică a datelor obținute.
5. Faceți o prezentare grafică a datelor obținute.
6. Faceți o concluzie asupra lucrării efectuate.

Considerații teoretice

Complexitatea timp a algoritmilor de sortare menționați este următoarea:

1. Merge Sort:
 Complexitatea timp în cel mai rău caz: O(n log n)
 Complexitatea timp în cazul mediu: O(n log n)
 Complexitatea timp în cel mai bun caz: O(n log n)
2. Quick Sort:
 Complexitatea timp în cel mai rău caz: O(n2) (dar cu alegeri bune ale pivotului sau cu
strategii de optimizare, poate avea O(n log n) în medie)
 Complexitatea timp în cazul mediu: O(n log n)
 Complexitatea timp în cel mai bun caz: O(n log n)
3. Bubble Sort:
 Complexitatea timp în cel mai rău caz: O(n2)
 Complexitatea timp în cazul mediu: O(n2)
 Complexitatea timp în cel mai bun caz: O(n) (dar acest caz este rar întâlnit și necesită o listă
deja sortată sau aproape sortată)
În general, Merge Sort și Quick Sort sunt algoritmi mai eficienți decât Bubble Sort în ceea ce
privește timpul de execuție, mai ales pentru liste mari. Bubble Sort este adesea folosit în scopuri
educaționale sau pentru liste foarte mici, întrucât performanța sa este foarte scăzută pe liste mai mari

Mersul lucrării

1. Implementarea algoritmilor propuși într-un limbaj de programare

2. Stabiliți proprietățile datelor de intrare în raport cu care se face analiza
3. Alegeți metrica pentru compararea algoritmilor propuși
4. Efectuați analiza emprică a algoritmilor propuși
5. Faceți o prezentare grafică a datelor obținute
6. Faceți o concluzie asupra lucrării efectuate

3
 Secvențele în C++

Merge sort:

void merge(vector<int> &arr, int low, int mid, int high, int *iterations)
{
*iterations = 0;
int n1 = mid - low + 1;
int n2 = high - mid;

vector<int> left(n1);
vector<int> right(n2);

for (int i = 0; i < n1; i++)

{
left[i] = arr[low + i];
}
for (int i = 0; i < n2; i++)
{
right[i] = arr[mid + 1 + i];
}

int i = 0, j = 0, k = low;
while (i < n1 && j < n2)
{
(*iterations)++;
if (left[i] <= right[j])
{
arr[k] = left[i];
i++;
}
else
{
arr[k] = right[j];
j++;
} k+
+;
}

while (i < n1)

{
arr[k] = left[i];
i++;
k++;
}

while (j < n2)

{
arr[k] = right[j];
j++;
k++;
}
}

void mergeSort(vector<int> &arr, int low, int high, int *iterations)

{
if (low < high)
{
int mid = low + (high - low) / 2;
mergeSort(arr, low, mid, iterations);
mergeSort(arr, mid + 1, high, iterations);
merge(arr, low, mid, high, iterations);

4
 }
}

Quick sort:

int partition(vector<int> &arr, int low, int high, int *iterations)

{
int pivot = arr[high];
int i = (low - 1);

for (int j = low; j <= high - 1; j++)

{
(*iterations)++;
if (arr[j] < pivot)
{
i++;
swap(arr[i], arr[j]);
}
}
swap(arr[i + 1], arr[high]);
return i + 1;
}

void quickSort(vector<int> &arr, int low, int high, int *iterations)

{
if (low < high)
{
int pivotIndex = partition(arr, low, high, iterations);
quickSort(arr, low, pivotIndex - 1, iterations);
quickSort(arr, pivotIndex + 1, high, iterations);
}
}

Bubble sort:

void bubbleSort(vector<int> &arr, int *iterations)

{
int n = arr.size();
*iterations = 0;

for (int i = 0; i < n - 1; i++)

{
bool swapped = false;

for (int j = 0; j < n - i - 1; j++)

{
(*iterations)++;
if (arr[j] > arr[j + 1])
{
swap(arr[j], arr[j + 1]);
swapped = true;
}
}

if (!swapped)
{
break;
}
}
}
5
 Proprietățile datelor de intrare în raport cu care se face analiza

Datele de intrare reprezintă un array static de numere întregi, și câte un counter pentru fiecare metodă.
Array-ul conține 100 de numere din intervalul [0-500], care nu se repetă.

Analiza empirică a algoritmilor

Analiza empirică a algoritmului este o metodă de evaluare a performanței unui algoritm prin observarea și
măsurarea comportamentului său în practică, adică în condiții reale de utilizare.

Metrica folosită pentru compararea algoritmilor

Algoritmele vor fi comparate după numărul de iterații folosit pentru același array. Acesta este un criteriu care
ne va indica performanța sa, viteza și resursele utilizate pentru compilare.

Tabelul valorilor:

Nr de 10 20 30 40 50 60 70 80 90 100
elemente.
Merge 9 18 29 39 47 50 65 66 86 100
Quick 20 62 118 179 245 272 334 497 566 609
Bubble 39 169 434 744 1128 1357 2124 2405 3741 4897

Reprezentarea grafică a analizei empirice

6000

5000

4000

3000

2000

1000

0
10 20 30 40 50 60 70 80 90 100

MergeSort QuickSort BubbleSort

Figură 1 – Comparația numărului de iterații dintre toate cele 3 metode

6
 800

700

600

500

400

300

200

100
10 20 30 40
0
MergeSort QuickSort BubbleSort
Figură 2 - Comparația nr. de iterații dintre metode (scară mai mică)

200
180
160
140
120
100
80
60
40
20
0

10 20 30 40

MergeSort QuickSort

Figură 3 - Comparația doar între cele două metode

Concluzie

Concluzia este că Merge Sort și Quick Sort sunt algoritmi de sortare mai eficienți din punct de vedere al
timpului de execuție în comparație cu Bubble Sort. Atât Merge Sort, cât și Quick Sort au o complexitate medie de
timp de O(n log n), ceea ce îi face adecvați pentru sortarea listelor de dimensiuni mari. În schimb, Bubble Sort are o
complexitate medie de timp de O(n^2), ceea ce îl face ineficient pentru liste mai mari, deoarece necesită un număr
semnificativ de comparații și interschimbări.

Este recomandabil să utilizați Merge Sort sau Quick Sort, în funcție de context și de cerințele specifice ale aplicației.
Bubble Sort este mai potrivit pentru scopuri educaționale sau pentru liste foarte mici, unde complexitatea sa mai mare
nu are un impact semnificativ asupra performanței.

7
 Anexa 1. Codul sursă

#include <iostream>

#include <vector>

using namespace std;

void bubbleSort(vector<int> &arr, int *iterations)

int n = arr.size();

*iterations = 0;

for (int i = 0; i < n - 1; i++)

bool swapped = false;

for (int j = 0; j < n - i - 1; j++)

(*iterations)++;

if (arr[j] > arr[j + 1])

swap(arr[j], arr[j + 1]);

swapped = true;

if (!swapped)

break;

8
 }

void merge(vector<int> &arr, int low, int mid, int high, int *iterations)

*iterations = 0;

int n1 = mid - low + 1;

int n2 = high - mid;

vector<int> left(n1);

vector<int> right(n2);

for (int i = 0; i < n1; i++)

left[i] = arr[low + i];

for (int i = 0; i < n2; i++)

right[i] = arr[mid + 1 + i];

int i = 0, j = 0, k = low;

while (i < n1 && j < n2)

(*iterations)++;

if (left[i] <= right[j])

arr[k] = left[i];

i++;

9
 else

arr[k] = right[j];

j++;

} k+

+;

while (i < n1)

arr[k] = left[i];

i++;

k++;

while (j < n2)

arr[k] = right[j];

j++;

k++;

void mergeSort(vector<int> &arr, int low, int high, int *iterations)

if (low < high)

int mid = low + (high - low) / 2;

mergeSort(arr, low, mid, iterations);

mergeSort(arr, mid + 1, high, iterations);

10
 merge(arr, low, mid, high, iterations);

int partition(vector<int> &arr, int low, int high, int *iterations)

int pivot = arr[high];

int i = (low - 1);

for (int j = low; j <= high - 1; j++)

(*iterations)++;

if (arr[j] < pivot)

i++;

swap(arr[i], arr[j]);

swap(arr[i + 1], arr[high]);

return i + 1;

void quickSort(vector<int> &arr, int low, int high, int *iterations)

if (low < high)

int pivotIndex = partition(arr, low, high, iterations);

quickSort(arr, low, pivotIndex - 1, iterations);

quickSort(arr, pivotIndex + 1, high, iterations);

11
}

int main()

vector<int> arr = {469, 165, 301, 17, 67, 168, 247, 253, 488, 138, 109, 425,
164,
303, 333, 315, 407, 404, 250, 112, 387, 73, 41, 297, 48, 193, 150, 280, 199, 440,
206, 223, 74, 126, 380, 64, 163, 45, 235, 447, 475, 166, 83, 345, 211, 202, 181,
485,
112, 159, 320, 185, 368, 426, 444, 254, 396, 396, 220, 119, 255, 429, 260, 215, 434,
390, 84, 303, 392, 302, 136, 237, 78, 314, 153, 209, 98, 57, 435, 379, 189, 276,
479,
222, 54, 77, 22};

int n = arr.size();

vector<int> arrBubble = arr;

vector<int> arrMerge = arr;

vector<int> arrQuick = arr;

int bubbleIterations = 0;

int mergeIterations = 0;

int quickIterations = 0;

bubbleSort(arrBubble, &bubbleIterations);

mergeSort(arrMerge, 0, n - 1, &mergeIterations);

quickSort(arrQuick, 0, n - 1, &quickIterations);

cout << "Original array: ";

for (int num : arr)

cout << num << " ";

cout << endl;

12
cout << "Merge sorted array: ";

13
 for (int num : arrMerge)

cout << num << " ";

cout << " (Iterations: " << mergeIterations << ")" << endl;

cout << "Quick sorted array: ";

for (int num : arrQuick)

cout << num << " ";

cout << " (Iterations: " << quickIterations << ")" << endl;

cout << "Bubble sorted array: ";

for (int num : arrBubble)

cout << num << " ";

cout << " (Iterations: " << bubbleIterations << ")" << endl;

return 0;

}
Exemplu de afișare

14