Universitatea Tehnică a Moldovei

Facultatea Calculatoare, Informatică și Microelectronică

Departamentul Ingineria Software și Automatică

RAPORT
la Lucrarea de laborator nr. 2
la disciplina Analiza și Proiectarea Algoritmilor

Tema: METODA DIVIDE ET IMPERA

A îndeplinit: Ursu Nicoleta, TI-184

A verificat: 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

3. Analiza empirică a algoritmilor de sortare(Quick Sort, Merge Sort, Selection Sort).

Realizarea sarcinii
Pentru realizarea sarcinii am implementat algoritmii Quick Sort și Merge Sort indicați în lucrare,
precum și un algoritm de sortare la alegere.

1.1 Cazul favorabil

Tabelul 2.1 – Numărul de prelucrări în cazul favorabil
n 100 500 1000 5000
Quick Sort 99 499 999 4999
Merge Sort 356 2272 5044 32 004
Selection Sort 99 499 999 4999

1.2 Cazul defavorabil

Tabelul 2.2 – Numărul de prelucrări în cazul defavorabil
n 100 500 1000 5000
Quick sort 369 2074 4346 22 542
Merge sort 1256 8400 18 830 119 137
Selection sort 297 1497 2997 14 997

1.1 Cazul mediu

Tabelul 2.3 – Numărul de prelucrări în cazul mediu
n 100 500 1000 5000
Quick sort 270 1575 3347 17543
Merge sort 900 6128 13786 87 133
Selection Sort 198 998 1998 9998

2
 Reprezentarea grafică a complexității algoritmilor în cazul mediu

Observăm că liniile reprezentând Quick Sort și Selection Sort aproape se suprapun,

Merge Sort-ul fiind mai instabil și crescând considerabil numărul de iterații odată cu
creșterea numerelor elementelor.
Rezultatul execuției
n=30 Quick Sort:

3
 Merge Sort:

Selection Sort:

4
Listingul Programului:
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
int A, N;
//------------------------------------
void ascending(int* a,int n){
int i;
for(i=0;i<N;i++){
a[i]=i;
cout<<a[i]<<" ";
}
cout<<endl;}
void descending(int* a, int n){
int i;
for(i=N;i>=0;i--){
a[i]=i;
cout<<a[i]<<" ";
}
cout<<endl;
}
void rand(int* a, int n){
int i;
for(i=0;i<N;i++){
a[i]=rand()%100-23;
cout<<a[i]<<" ";
}
cout<<endl;
}
//-----------------------------------------------
void qsort(int a[],int first,int last)
{
int i, j, pivot, temp;
if(first<last){
pivot=first;
i=first;

5
j=last;
while(i<j) {
while(a[i] <= a[pivot] && i<last)
i++;
while(a[j]>a[pivot])
j--;
if(i<j) {
temp=a[i];
a[i]=a[j];
a[j]=temp;
A++;
}}
temp=a[pivot];
a[pivot]=a[j];
a[j]=temp; A++;
qsort(a,first,j-1);
qsort(a,j+1,last);}
//----------------------------------------------
void swap(int *xp, int *yp)
{
int temp = *xp;
*xp = *yp;
*yp = temp;
}

void selectionSort(int a[], int n)

{
int i, j, min_idx;
for (i = 0; i < n-1; i++)
{
min_idx = i;
for (j = i+1; j < n; j++)
if (a[j] < a[min_idx])
min_idx = j;
swap(&a[min_idx], &a[i]);
A++;
}

6
}
//---------------------------------------------------
void merge(int *a, int start, int mid, int end) {
int temp[end - start + 1];
int i = start, j = mid+1, k = 0;
while(i <= mid && j <= end) {
if(a[i] <= a[j]) {
temp[k] = a[i];
k += 1; i += 1;}
else {
temp[k] = a[j];
k += 1; j += 1;}
A++;}
while(i <= mid) {
temp[k] = a[i];
k += 1; i += 1; }
while(j <= end) {
temp[k] = a[j];
k += 1; j += 1; }
for(i = start; i <= end; i += 1) {
a[i] = temp[i - start];
}}

void mergeSort(int *a, int start, int end) {

if(start < end) {

int mid = (start + end) / 2;
mergeSort(a, start, mid);
mergeSort(a, mid+1, end);
merge(a, start, mid, end);}
}
//-----------------------------------------------------------
void printArray(int A[], int size)
{
int i;
for (i=0; i < size; i++)
printf("%d ", A[i]);
printf("\n");

7
}

void stats(){
printf("\n Pasi: %d",A);
printf("\n\n");}
int main()
{
Numere:
cout<<"Introdu nr de elemente\n";
cin>>N;
int a[N],i;
int b[N],c[N],d[N];
int nr_menu;
printf("\n\n");
printf("0. Introdu alt numar de elemente.\n");
printf("1. Quick Sort.\n");
printf("2. Merge Sort.\n");
printf("3. Selection Sort.\n");
printf("\n\n");
Menu:
printf("Alege o optiune: ");
scanf("%d",&nr_menu);
printf("\n");
switch(nr_menu)
{
case 1:
{
for(i=0; i<N; i++){
b[i] = a[i];
c[i] = a[i];
d[i] = a[i];
}
printf("\nQuick Sort:\n\n");
cout<<"Caz favorabil:\n";
ascending(b,N);
qsort(b,0,N-1);
printArray(b, N);
stats();

8
cout<<"Caz mediu:\n";
rand(c,N);
qsort(c,0,N-1);
printArray(c, N);
stats();
cout<<"Caz defavorabil\n";
descending(d,N);
qsort(d,0,N-1);
printArray(d,N);
stats();
A = 0; goto Menu;}
case 2:{
for(i=0;i<N;i++){
b[i]=a[i];
c[i]=a[i];
d[i]=a[i]; }
printf("\nMerge Sort:\n");
cout<<"Caz favorabil:\n";
ascending(b,N);
mergeSort(b, 0, N - 1);
printArray(b, N);

stats();
cout<<"Caz mediu:\n";
rand(c, N);
mergeSort(c, 0, N-1);
printArray(c, N);
stats();
<<"Caz defavorabil:\n";
descending(d,N);
mergeSort(d, 0, N-1);
printArray(d,N);
stats();
A = 0;
Menu; }
case 3:{
for(i=0; i<N; i++){
b[i] = a[i]; c[i] = a[i]; d[i] = a[i];

9
 }
printf("\nSelectie:\n");
cout<<"Caz favorabil:\n";
ascending(b,N);
selectionSort(b,N);
printArray(b,N);
stats();
cout<<"Caz mediu:\n";
rand(c,N);
selectionSort(c,N);
printArray(c,N);
stats();
cout<<"Caz defavorabil:\n";
descending(d,N);
selectionSort(d,N);
printArray(d,N);
stats();
A = 0;
goto Menu;}
case 0:{
goto Numere;
break; }
default:{printf("Apasa orice tasta pentru a continua..."); exit(1);}
}
}

Concluzii

În urma efectuării lucrării de laborator am analizat empiric 3 algoritmi diferiți de sortare a unui vector
de n elemente: Quick Sort, Merge Sort și Selection Sort.
Pentru analiza empirică am implementat în limbajul de programare C++ cei 3 algoritmi, și am testat
programul pentru toate cele 3 cazuri: favorabil, când vectorul este deja sortat, defavorabil, când vectorul
este sortat invers, mediu, când este dat un tablou random. Pentru o analiză mai eficientă programul a fost
rulat pentru mai multe valori ale lui n (100, 5000, 1000, 5000). Compararea algoritmilor a fost realizată
după numărul de prelucrări, și anume după numărul de comparări și interschimbare al elementelor
vectorului.
Quick Sort și Selection Sort s-au dovedit a fi cei mai eficienți, pe când eficiența algoritmului Merge
Sort a scăzut considerabil odată cu creșterea numărului de elemente.

10