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 Lungu Constantin

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 Java

Merge sort:

import java.util.Vector;

public class MergeSort {

public static void merge(Vector<Integer> arr, int low, int mid, int high, int[] iterations) {
iterations[0] = 0;
int n1 = mid - low + 1;
int n2 = high - mid;

Vector<Integer> left = new Vector<>(n1);

Vector<Integer> right = new Vector<>(n2);

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

left.add(arr.get(low + i));
}
for (int i = 0; i < n2; i++) {
right.add(arr.get(mid + 1 + i));
}

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

while (i < n1) {

arr.set(k, left.get(i));
i++;
k++;
}

while (j < n2) {

arr.set(k, right.get(j));
j++;
k++;
}
}

public static void mergeSort(Vector<Integer> 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);
}
}

public static void main(String[] args) {

Vector<Integer> arr = new Vector<>();
arr.add(12);
arr.add(11);

4
 arr.add(13);
arr.add(5);
arr.add(6);
arr.add(7);

int[] iterations = new int[1];

System.out.println("Vectorul nesortat: " + arr);

mergeSort(arr, 0, arr.size() - 1, iterations);
System.out.println("Vectorul sortat: " + arr);
System.out.println("Numărul de iterații: " + iterations[0]);
}
}

Quick sort:

import java.util.Vector;

public class QuickSort {

public static int partition(Vector<Integer> arr, int low, int high, int[] iterations) {
int pivot = arr.get(high);
int i = (low - 1);

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

iterations[0]++;
if (arr.get(j) < pivot) {
i++;
// Schimbarea elementelor la pozițiile i și j
int temp = arr.get(i);
arr.set(i, arr.get(j));
arr.set(j, temp);
}
}

// Schimbarea elementelor la pozițiile (i + 1) și high (pivot)

int temp = arr.get(i + 1);
arr.set(i + 1, arr.get(high));
arr.set(high, temp);

return i + 1;
}

public static void quickSort(Vector<Integer> 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);
}
}

public static void main(String[] args) {

Vector<Integer> arr = new Vector<>();
arr.add(12);
arr.add(11);
arr.add(13);
arr.add(5);
arr.add(6);
arr.add(7);

int[] iterations = new int[1];

System.out.println("Vectorul nesortat: " + arr);

5
 quickSort(arr, 0, arr.size() - 1, iterations);
System.out.println("Vectorul sortat: " + arr);
System.out.println("Numărul de iterații: " + iterations[0]);
}
}

Bubble sort:

import java.util.Vector;

public class BubbleSort {

public static void bubbleSort(Vector<Integer> arr, int[] iterations) {

int n = arr.size();
iterations[0] = 0;

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

boolean swapped = false;

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

iterations[0]++;
if (arr.get(j) > arr.get(j + 1)) {
// Schimbarea elementelor la pozițiile j și (j + 1)
int temp = arr.get(j);
arr.set(j, arr.get(j + 1));
arr.set(j + 1, temp);
swapped = true;
}
}

if (!swapped) {
// Dacă nu s-au făcut schimbări într-o iterație, vectorul este deja sortat
break;
}
}
}

public static void main(String[] args) {

Vector<Integer> arr = new Vector<>();
arr.add(64);
arr.add(34);
arr.add(25);
arr.add(12);
arr.add(22);
arr.add(11);
arr.add(90);

int[] iterations = new int[1];

System.out.println("Vectorul nesortat: " + arr);

bubbleSort(arr, iterations);
System.out.println("Vectorul sortat: " + arr);
System.out.println("Numărul de iterații: " + iterations[0]);
}
}

6
 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

7
 800

700

600

500

400

300

200

100

0
10 20 30 40

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.

8
9