Ministerul Educației, Culturii și Cercetării al Republicii Moldova

Universitatea Tehnică a Moldovei

Facultatea Calculatoare, Informatică și Microelectronică

Raport la
Lucrarea de laborator Nr. 3
Disciplina: Algoritmi si proiectarea algoritmilor

Tema: ” Metoda divide et impera.”

Au efectuat: Botnaru Alexandru

A verificat: Mihai Gaidau

Chișinău – 2020
 Scopul lucrării: 1. Analiza empirică a algoritmilor

SARCINA DE BAZĂ:
1. Studiaţi noţiunile teoretice despre metoda divide et impera.
2. Implementaţi algoritmii Mergesort şi Quicksort.
3. Efectuaţi analiza empirică a algoritmilor Mergesort şi
Quicksort.
4. Implementați +1 algoritm de sortare (algoritmul sa fie unic
per elev în subgrupa)
5. Faceţi o concluzie asupra lucrării efectuate.

Programul (JAVA):
public class MergeSort {
public
int[] Array;

long TimeElapsed(int[] tablou) {

long start = System.nanoTime();
mergeSort(tablou);
long end = System.nanoTime();
return end - start;
}

void afisare(int[] tablou, long exeTime) {

System.out.println("Merge sort:");
if (tablou.length<50) {
System.out.println("Tabloul sortat este: " +
Arrays.toString(tablou));
}
System.out.println("Timpul de executie in nanosecunde este: " +
exeTime);
}

private void mergeSort(int[] tablou) {

int numElem = tablou.length;
if (numElem < 2) {
return;
}
int mij = numElem / 2;
int[] stanga = new int[mij];
for (int i = 0; i < mij; i++) {
stanga[i] = tablou[i];
}
 int[] dreapta = new int[numElem - mij];
for (int i = mij; i < numElem; i++) {
dreapta[i - mij] = tablou[i];
}
mergeSort(stanga);
mergeSort(dreapta);
Merge(stanga, dreapta, tablou);
Array = tablou;
}

void Merge(int[] stanga, int[] dreapta, int[] tablou) {

int i = 0, j = 0, k = 0;
while (i < stanga.length && j < dreapta.length) {
if (stanga[i] <= dreapta[j]) {
tablou[k] = stanga[i];
i++;
k++;
} else {
tablou[k] = dreapta[j];
j++;
k++;
}
}
while (i < stanga.length) {
tablou[k] = stanga[i];
i++;
k++;
}
while (j < dreapta.length) {
tablou[k] = dreapta[j];
j++;
k++;
}
}
}

class QuickSort
{
public int Array[];

long TimeElapsed(int[] tablou, int indexLeft, int indexRight)

{
long start = System.nanoTime();
quickSort(tablou, indexLeft, indexRight);
long end = System.nanoTime();
return end - start;
}

void afisare(int[] tablou, long exeTime)

{
System.out.println("Quick sort:");
if (tablou.length<50) {
System.out.println("Tabloul sortat este: " +
Arrays.toString(tablou));
}
System.out.println("Timpul de executie in nanosecunde este: " +
exeTime);
 }

private
void quickSort(int[] arr, int indexLeft, int indexRight)
{
if(indexLeft >= indexRight)
{
return;
}
int pivotIndex = partition(arr, indexLeft, indexRight);
quickSort(arr, indexLeft, pivotIndex - 1);
quickSort(arr, pivotIndex + 1, indexRight);
Array = arr;
}

int partition(int[] arr, int indexLeft, int indexRight)

{

int aux;
int pivot = arr[indexRight];
int pivotIndex = indexLeft;
for(int i = indexLeft; i < indexRight; i++)
{
if(pivot >= arr[i])
{
aux = arr[pivotIndex];
arr[pivotIndex] = arr[i];
arr[i] = aux;
pivotIndex++;
}
}
aux = arr[indexRight];
arr[indexRight] = arr[pivotIndex];
arr[pivotIndex] = aux;
return pivotIndex;
}
}

class GnomeSort
{

long TimeElapsed(int[] arr, int n )

{
long start = System.nanoTime();
gnomeSort(arr, n);
long end = System.nanoTime();
return end - start;
}

void afisare(int[] tablou, long exeTime)

{
System.out.println("Gnome sort:");
if (tablou.length<50) {
System.out.println("Tabloul sortat este: " +
Arrays.toString(tablou));
}
System.out.println("Timpul de executie in nanosecunde este: " +
exeTime);
}

void gnomeSort(int arr[], int n)

{
int pos = 0;

while (pos < n) {

if (pos == 0)
pos++;
if (arr[pos] >= arr[pos - 1])
pos++;
else {
int temp = 0;
temp = arr[pos];
arr[pos] = arr[pos - 1];
arr[pos - 1] = temp;
pos--;
}
}

}
}

import java.util.Scanner;

class ArrayNesortat {
static int num;

int[] ArrayNesortatInput(int[] Array) {

char cazul;
Scanner sc = new Scanner(System.in);
num = citireaNum(sc);
int incr = 0;
Array = new int[num];
System.out.println("Dati cazul pentru care se aleg valorile din array:
r - random, c - ordonat crescator, d - ordonat descrescator");
cazul = sc.next().charAt(0);
sc.close();
System.out.println("Dati valorile din array: ");
switch (cazul) {
case 'r':

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

Array[i] = (int) (Math.random() * ((num - 0) + 1)) + 0;
}
break;
case 'c':
for (int i = 0; i < num; i++) {
Array[i] = i;
}
break;
case 'd':
for (int i = num - 1; i >= 0; i--) {
Array[incr] = i;
 incr++;
}
break;
}
return Array;
}

int citireaNum(Scanner sc) {

int num;
System.out.print("Dati numarul de elemente din array-ul nesortat: ");
num = sc.nextInt();
return num;
}

void ArrayNesortatOutput(int[] Array) {

System.out.print("Se afiseaza array-ul nesortat: ");
for (int i : Array) {
System.out.print(i + " ");
}
System.out.println();
}
}

public class Main {

public static void main(String args[])

{
ArrayNesortat nesortat = new ArrayNesortat();
int[] arr = new int[0];
arr = nesortat.ArrayNesortatInput(arr);
nesortat.ArrayNesortatOutput(arr);

GnomeSort gs = new GnomeSort();

long exeTime3 = gs.TimeElapsed(arr, arr.length );
gs.afisare(arr, exeTime3);

MergeSort mergsort = new MergeSort();

long exeTime1 = mergsort.TimeElapsed(arr);
mergsort.afisare(arr, exeTime1);

QuickSort quick = new QuickSort();

long exeTime2 = quick.TimeElapsed(arr, 0, ArrayNesortat.num - 1);
quick.afisare(arr, exeTime2);

}
}
Pentru tablouri random:
n=10

n=100

n=500

n=1000
n=2000

n=5000

180000000

160000000

140000000

120000000
Numarul de iteratii

100000000

80000000

60000000

40000000

20000000

0
n=10 n=100 n=500 n=1000 n=2000 n=5000

GnomeSort MergeSort QuickSort

Pentru tablouri ordonate crescator:

n=50

n=500
n=2000

n=5000

200000000

180000000

160000000

140000000
Numarul de iteratii

120000000

100000000

80000000

60000000

40000000

20000000

0
n=50 n=500 n=2000 n=5000

GnomeSort MergeSort QuickSort

Pentru tablouri ordonate descrescator:
n=100

n=1000

n=2000

n=5000
 180000000

160000000

140000000

120000000
Numarul de iteratii

100000000

80000000

60000000

40000000

20000000

0
n=100 n=1000 n=2000 n=5000

GnomeSort MergeSort QuickSort

Gnome Sort : O(N^2), O(n) in cel mai bun caz

Merge Sort : O(nLogn) – pentru toate cazurile
Quick Sort: O(n log n) ,O(n^2) in cel mai rau caz

Concluzie:
Scopul acestei lucrari de laborator a fost de a efectua analiza
empirica a 3 algoritmi destinati rezolvarii aceleiasi probleme : de a sorta
un tablou de numere in ordine crescatoare.Conform rezultatelor
obtinute,pot spune ca Merge Sort este cel mai optim algoritm dintre
acestea 3.Quick Sortul este eficient la sortarea unui tablou cu putine
elemente, iar Gnome Sortul este foarte eficient in cazul in care tabloul
este deja sortat, Merge Sortul avand o complexitate buna in toate
cazurile.