Ministerul Educației, Culturii și

Cercetării
Universitatea Tehnică a
Moldovei
Facultatea Calculatoare,
Informatică şi Microelectronică
Departamentul Ingineria
Software și Automatică

Metoda divide et impera

Lucrare de laborator nr.2
Disciplina: Analiza şi Proiectarea Algoritmilor

Studenta gr. TI-181: Erhan Serghei

Asistent Universitar: Buldumac Oleg
 Chișinău 2019
Scopul lucrării:
1. Studierea metodei divide et impera.
2. Analiza şi implementarea algoritmilor bazaţi pe metoda divide et impera.

Mersul lucrării:
Divide et impera este o tehnica de elaborare a algoritmilor care constă în:
1. Descompunerea cazului ce trebuie rezolvat într-un număr de subcazuri mai mici ale aceleiaşi
probleme.
2. Rezolvarea succesivă şi independentă a fiecăruia din aceste subcazuri.
3. Combinarea subsoluţiilor astfel obţinute pentru a găsi soluţia cazului iniţial.
Algoritmul formal al metodei divide et impera:

Vom utiliza 3 algoritmi de sortare: Merge Sort, Quicksort și Insertion.

Merge Sort (sortarea prin interclasare)

Merge Sort este unul dintre algoritmii cei mai eficienți de sortare. Lucrează pe principiul Divide et
impera. Merge Sort descompune în mod repetat o listă în mai multe subliste, până când fiecare sublistă
constă dintr-un singur element și îmbinând acele subliste într-o manieră care duce într-o listă sortată.
Quick Sort (sortarea rapidă)
Quick Sort selectează un element ca pivot și împarte matricea dată în jurul pivotului selectat.
Există multe versiuni diferite ale Quick Sort care aleg pivotul în diferite moduri:
 Alegeți întotdeauna primul element ca pivot;
 Alegeți întotdeauna ultimul element ca pivot (implementat mai jos);
 Alegeți un element aleatoriu ca pivot;
 Alegeți medianul ca pivot.

Insertion Sort
Insertion Sort se bazează pe ideea că un element din elementele de intrare este consumat în fiecare
iterație pentru a-și găsi poziția corectă, adică poziția în care aparține într-o matrice sortată.
Se iterează elementele de intrare prin creșterea matricei sortate la fiecare iterație. Compară
elementul curent cu cea mai mare valoare din matricea sortată. Dacă elementul curent este mai mare,
atunci acesta părăsește elementul în locul său și se deplasează la următorul element, altfel își găsește
poziția corectă în matricea sortată și o deplasează în acea poziție. Aceasta se face prin deplasarea tuturor
elementelor, care sunt mai mari decât elementul curent, în matricea sortată la o poziție în față
Listing Program:
#include <iostream>
#include <ctime>
#include <cstdlib>

using namespace std;

int * Randomize(int n){

int *random= new int[n];
srand((unsigned)time(NULL));
for (int i = 0; i < n; i++)
{
random[i] = (rand()%1000)+1;
}
return random;
}

int * Favorabil(int n){

int *iter= new int[n];
for (int i = 0; i < n; i++)
{
iter[i] = i;
}
return iter;
}

int * NeFavorabil(int n){

int *nefavorabil= new int[n];
int k=n;
for(int i=0; i<n; i++){
nefavorabil[i]=k;
k--;
}
return nefavorabil;
}

//---- MergeSort
int Merge(int *a, int low, int high, int mid)
{
long num;
int i, j, k, temp[high-low+1];
i = low;
k = 0;
j = mid + 1;

while (i <= mid && j <= high)

{
 if (a[i] < a[j])
{
temp[k] = a[i];
k++;
i++;
num++;
}
else
{
temp[k] = a[j];
k++;
j++;
num++;
}
}

while (i <= mid)

{
temp[k] = a[i];
k++;
i++;
num++;
}

while (j <= high)

{
temp[k] = a[j];
k++;
j++;
num++;
}

for (i = low; i <= high; i++)

{
a[i] = temp[i-low];
num++;
}
return num;
}

int MergeSort(int *a, int low, int high)

{
int mid;
long iteration;
if (low < high)
{
mid=(low+high)/2;
MergeSort(a, low, mid);
MergeSort(a, mid+1, high);
iteration=Merge(a, low, high, mid);
 }
return iteration;

//---- QuickSort
int swap(int* a, int* b)
{
long num=0;
int t = *a;
num++;
*a = *b;
num++;
*b = t;
num++;
return num;
}

int partition (int *arr, int low, int high, long num)
{
int pivot = arr[high];
int i = (low - 1);

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

{
if (arr[j] <= pivot)
{
i++;
num++;
swap(&arr[i], &arr[j]);
num=num+swap(&arr[i], &arr[j]);
}
}
swap(&arr[i + 1], &arr[high]);
num=num+swap(&arr[i + 1], &arr[high]);
return (i + 1);
}
int quickSort(int *arr, int low, int high)
{
int num;
long iteration=0;
if (low < high)
{
int pi = partition(arr, low, high, num);

quickSort(arr, low, pi - 1);

quickSort(arr, pi + 1, high);
iteration = partition(arr, low, high, num);
}
return iteration;
}
//---- Insertion
int insertionSort(int *a, int length) {

int i, j, tmp;
long iteration=0;
for (i = 0; i < length; i++) {
j = i;
while (j > 0 && a[j - 1] > a[j]) {
tmp = a[j];
iteration++;
a[j] = a[j - 1];
iteration++;
a[j - 1] = tmp;
iteration++;
j--;
}
}
return iteration;
}

int main()
{
int n=10000;
int *arr= new int[n];
int *favorabil= new int[n];
int *nefavorabil= new int[n];
int number[4]={10,100,1000,10000};
arr=Randomize(n);
favorabil=Favorabil(n);
nefavorabil=NeFavorabil(n);

cout<<endl<<endl<<"QuickSort-Random:"<<endl;
for(int i=0 ; i<4; i++){
long iteration_quick_random=quickSort(arr, 0, number[i]-1);
cout<<"t["<<number[i]<<"]="<<iteration_quick_random<<" ";
}

cout<<endl<<endl<<"\nQuickSort-Nefavorabil:"<<endl;
for(int i=0 ; i<4; i++){
long iteration_quick_favorabil=quickSort(favorabil, 0, number[i]-1);
cout<<"t["<<number[i]<<"]="<<iteration_quick_favorabil<<" ";
}

cout<<endl<<endl<<"\nQuickSort-Favorabil:"<<endl;
for(int i=0 ; i<4; i++){
long iteration_quick_nefavorabil=quickSort(nefavorabil, 0, number[i]-1);
cout<<"t["<<number[i]<<"]="<<iteration_quick_nefavorabil<<" ";
}
 arr=Randomize(n);
favorabil=Favorabil(n);
nefavorabil=NeFavorabil(n);

cout<<endl<<endl<<"\nMergeSort-Random:"<<endl;
for(int i=0 ; i<4; i++){
long iteration_merge_random=MergeSort(arr, 0, number[i]-1);
cout<<"t["<<number[i]<<"]="<<iteration_merge_random<<" ";
}

cout<<endl<<endl<<"\nMergeSort-Favorabil:"<<endl;
for(int i=0 ; i<4; i++){
long iteration_merge_favorabil=MergeSort(favorabil, 0, number[i]-1);
cout<<"t["<<number[i]<<"]="<<iteration_merge_favorabil<<" ";
}

cout<<endl<<endl<<"\nMergeSort-Nefavorabil:"<<endl;
for(int i=0 ; i<4; i++){
long iteration_merge_nefavorabil=MergeSort(nefavorabil, 0, number[i]-1);
cout<<"t["<<number[i]<<"]="<<iteration_merge_nefavorabil<<" ";
}

arr=Randomize(n);
favorabil=Favorabil(n);
nefavorabil=NeFavorabil(n);

cout<<endl<<endl<<"\nInsertionSort-Random:"<<endl;
for(int i=0 ; i<4; i++){
long iteration_insert_random=insertionSort(arr, number[i]-1);
cout<<"t["<<number[i]<<"]="<<iteration_insert_random<<" ";
}
cout<<endl<<endl<<"\nInsertionSort-Favorabil:"<<endl;
for(int i=0 ; i<4; i++){
long iteration_insert_favorabil=insertionSort(favorabil, number[i]-1);
cout<<"t["<<number[i]<<"]="<<iteration_insert_favorabil<<" ";
}

cout<<endl<<endl<<"\nInsertion Sort-Nefavorabil:"<<endl;
for(int i=0 ; i<4; i++){
long iteration_insert_nefavorabil=insertionSort(nefavorabil, number[i]-1);
cout<<"t["<<number[i]<<"]="<<iteration_insert_nefavorabil<<" ";
}

return 0;
}
Concluzie:
În cadrul acestei lucrări s-a analizat metoda „Divide et Impera”. S-au implementat modele de
sortare diferite din tehnica Divide et Impera și anume: QuickSort, MergeSort și Insertion Sort. Fiecare
algoritm lucrează dupa principiul lui de sortare, care au fost explicate pe parcursul lucrării de laborator.
Fiecare din acestea au fost adaptate la 3 cazuri: nefavorabil, random și favorabil. Conform datelor
determinate, s-au creat graficile pentru numărul de iterații la un anumit număr de elemente pe care le
sortează algoritmul la fiecare în parte.
În urma rezultatelor obținute, concluzionăm că metoda QuickSort este cea mai eficientă și
reprezintă soluția optimă pentru sortare, folosind un număr minim de iterații.