Documente Academic
Documente Profesional
Documente Cultură
APA Lab2 Russu Iulia TI-224
APA Lab2 Russu Iulia TI-224
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
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
Mersul lucrării
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);
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+
+;
}
4
}
}
Quick sort:
Bubble sort:
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 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.
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
6000
5000
4000
3000
2000
1000
0
10 20 30 40 50 60 70 80 90 100
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
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>
int n = arr.size();
*iterations = 0;
(*iterations)++;
swapped = true;
if (!swapped)
break;
8
}
void merge(vector<int> &arr, int low, int mid, int high, int *iterations)
*iterations = 0;
vector<int> left(n1);
vector<int> right(n2);
int i = 0, j = 0, k = low;
(*iterations)++;
arr[k] = left[i];
i++;
9
else
arr[k] = right[j];
j++;
} k+
+;
arr[k] = left[i];
i++;
k++;
arr[k] = right[j];
j++;
k++;
10
merge(arr, low, mid, high, iterations);
(*iterations)++;
i++;
swap(arr[i], arr[j]);
return i + 1;
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();
int bubbleIterations = 0;
int mergeIterations = 0;
int quickIterations = 0;
bubbleSort(arrBubble, &bubbleIterations);
mergeSort(arrMerge, 0, n - 1, &mergeIterations);
quickSort(arrQuick, 0, n - 1, &quickIterations);
12
cout << "Merge sorted array: ";
13
for (int num : arrMerge)
cout << " (Iterations: " << mergeIterations << ")" << endl;
cout << " (Iterations: " << quickIterations << ")" << endl;
cout << " (Iterations: " << bubbleIterations << ")" << endl;
return 0;
}
Exemplu de afișare
14