Ministerul Educaţiei, Culturii și Cercetării

Universitatea Tehnică a Moldovei

Facultatea Calculatoare Informatică şi Microelectronică
Departamentul Ingineria Software şi Automatică

RAPORT

Lucrare de laborator Nr.3

Analiza şi proiectarea algoritmilor
Tema: Algoritmii QuickSort și MergeSort

A efectuat: st.gr. TI-1

A verificat: Andrievschi-Bagrin Veronica

Chişinău 2018
 Cuprins

Cuprins ................................................................................................................................................. 1
Scopul și obiectivele lucrării ................................................................................................................ 3
Sarcina .................................................................................................................................................. 4
Mersul lucrării ...................................................................................................................................... 5
Analiza algoritmilor ............................................................................ Error! Bookmark not defined.
Concluzii............................................................................................................................................. 13
Anexa A .............................................................................................................................................. 14
Scopul și obiectivele lucrării

a. Identificarea numarului de iterații pentru fiecare din metode

 Sarcina

Să se determine numărul de iterații pentru n=10, n=100, n=1000, n=10000, n=100000 la sortarea unui
tablou în ordine crescătoare prin 3 metode(Mergesort, Quicksort, Mysort). Să fie luate în considerație
3 cazuri: favorabil, nefavorabil și random.
 Mersul lucrării

1) Metoda MergeSort
Algoritmul merge sort execută următorii pași

1. Dacă lista este de lungime 0 sau 1, atunci este deja sortată. Altfel:
2. Împarte lista nesortată în două subliste aproximativ egale.
3. Sortează fiecare sublistă recursiv prin reaplicarea algoritmului merge sort.
4. Se interclasează cele două liste și se obține lista inițială sortată.

MergeSort mai este denumit și algoritm de sortare prin interclasare , care are complexitatea

O(n*log n)

void merge(int arr[], int l, int m, int r)

int Left = m - l + 1;

int Right = r - m;

int subArrayLeft[Left], subArrayRight[Right];

for (i = 0; i < Left; i++) {

subArrayLeft[i] = arr[l + i]; }

for (j = 0; j < Right; j++) {

subArrayRight[j] = arr[m + 1+ j];}

i = 0;

j = 0;

k = l;

while (i < Left && j < Right)

{
 if (subArrayLeft[i] <= subArrayRight[j])

arr[k] = subArrayLeft[i];

i++;

else

arr[k] = subArrayRight[j];

j++;

k++;

while (i < Left)

arr[k] = subArrayLeft[i];

i++;

k++;

while (j < Right)

arr[k] = subArrayRight[j];

j++;

k++;

}
void mergeSort(int arr[], int l, int r)

it2++;

if (l < r)

int m = l+(r-l)/2;

mergeSort(arr, l, m);

mergeSort(arr, m+1, r);

merge(arr, l, m, r);

}
 2) Metoda QuickSort

int partition (int arr[], int low, int high)

int pivot = arr[high];

int i = (low - 1);

int j;

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

if (arr[j] <= pivot)

i++;

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

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

return (i + 1);

void quickSort(int arr2[], int low, int high)

if (low < high)

int pi = partition(arr2, low, high);

contor1++;
 quickSort(arr2, low, pi - 1);

quickSort(arr2, pi + 1, high);

}}

3) Metoda BubbleSort
void bubble_sort(int arr[], int num) {

int i, j=0, k, temp;

bool swapped = true;

while (swapped) {

swapped = false;

j++;

for (i = 0; i < num-j; i++) {

if (arr[i] > arr[i + 1]) {

temp = arr[i];

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

arr[i + 1] = temp;

swapped = true;

it3 = ((i)*(j));

}
 Numărul de iterații pentru cazul favorabil

Algoritm
MergeSort QuickSort BubbleSort
n
10 19 1 9
100 199 1 99
1000 1999 1 999
10000 19999 1 9999

Numărul de iterații pentru cazul defavorabil

Algoritm
MergeSort QuickSort BubbleSort
n
10 19 8 9
100 199 98 99
1000 1999 998 999
10000 19999 9998 9999

Numărul de iterații când lista este random

Algoritm
MergeSort QuickSort BubbleSort
n
10 19 10 9
100 199 195 99
1000 1999 1993 999
10000 19999 19996 9999
 Diagrama pentru cazul favorabil
25000

20000

15000

10000

5000

0
10 100 1000 10000

MergeSort QuickSort BubbleSort

Diagrama pentru cazul defavorabil

25000

20000

15000

10000

5000

0
10 100 1000 10000

MergeSort QuickSort BubbleSort

 Diagrama pentru cazul random
25000

20000

15000

10000

5000

0
10 100 1000 10000

MergeSort QuickSort BubbleSort

 Concluzii

Scopul propus de această lucrare a fost de a utiliza 3 metode de sortare a vectorilor – QuickSort,
MergeSort și BubbleSort. Executînd programele și de fiecare dată introducînd date de intrare diferite,
am aflat numărul de iterații pentru fiecare din algoritmi.
Cele mai multe resurse resurse ale calculatorului la un tablou de 10.000 de elemente a utilizat
algoritmul MergeSort, deci este unul mai ineficient, dar stabil pentru fiecare din cele 3
cazuri(favorabil, defavorabil sau random).
Cel mai eficient dintre algoritmi s-a dovedit a fi QuickSort, care are cele mai puține iterații, deci
și utilizează resurse mai puține.
Anexa A
Anexa B
#include<stdlib.h>

#include<stdio.h>

#include<iostream>

#define max_limit 100000

using namespace std;

int arr[max_limit], arr3[max_limit];

int i,j,k,it,it2,it3;

int n;

int r,l,m;

void merge(int arr[], int l, int m, int r)

int Left = m - l + 1;

int Right = r - m;

int subArrayLeft[Left], subArrayRight[Right];

for (i = 0; i < Left; i++) {

subArrayLeft[i] = arr[l + i]; }

for (j = 0; j < Right; j++) {

subArrayRight[j] = arr[m + 1+ j];}

i = 0;

j = 0;

k = l;

while (i < Left && j < Right)

if (subArrayLeft[i] <= subArrayRight[j])

arr[k] = subArrayLeft[i];

i++;

}
 else

arr[k] = subArrayRight[j];

j++;

k++;

while (i < Left)

arr[k] = subArrayLeft[i];

i++;

k++;

while (j < Right)

arr[k] = subArrayRight[j];

j++;

k++;

void mergeSort(int arr[], int l, int r)

it2++;

if (l < r)

int m = l+(r-l)/2;

mergeSort(arr, l, m);

mergeSort(arr, m+1, r);

merge(arr, l, m, r);

}
}

void swap(int* a, int* b)

int t = *a;

*a = *b;

*b = t;

int partition (int arr[], int low, int high)

int pivot = arr[high];

int i = (low - 1);

int j;

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

if (arr[j] <= pivot)

i++;

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

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

it = i + j;

return (i + 1);

void quickSort(int arr2[], int low, int high)

if (low < high)

int pi = partition(arr2, low, high);

 quickSort(arr2, low, pi - 1);

quickSort(arr2, pi + 1, high);

void printArray(int arr[], int n)

int i;

for (i=0; i < n; i++)

std::cout<<arr[i]<<" ";

std::cout<<endl;

void bubble_sort(int arr[], int num) {

int i, j=0, k, temp;

bool swapped = true;

while (swapped) {

swapped = false;

j++;

for (i = 0; i < num-j; i++) {

if (arr[i] > arr[i + 1]) {

temp = arr[i];

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

arr[i + 1] = temp;

swapped = true;

cout << endl;

it3 = ((i)*(j));

int main()

n=100;for(i=0,j=n;i<n;i++,j--){arr[i]=j;} //caz nefavorabil

//n=100;for(i=0,j=1;i<n;i++,j++){arr[i]=j;} //caz favorabil

 /*n=10;

for(i=0;i<n;i++){

std::cin>>arr[i];

}*/

int* arr2=arr;

int* arr3=arr;

cout<<"Tabloul dat: \n";

printArray(arr, n);

quickSort(arr2, 0, n-1);

std::cout<<"\nTabloul sortat print metoda QuickSort:\n";

printArray(arr2, n);

std::cout<<"Nr. de iteratii="<<it<<"\n\n";

mergeSort(arr, 0, n-1);

std::cout<<"\nTabloul sortat print metoda MergeSort:\n";

printArray(arr, n);

std::cout<<"Nr. de iteratii="<<it2<<"\n\n";

bubble_sort(arr3, n);

std::cout<<"\nTabloul sortat print metoda BubbleSort:\n";

printArray(arr3, n);

std::cout<<"Nr. de iteratii="<<it3<<"\n\n";

return 0;