Ministerul Educaţiei

al Republicii Moldova

Universitatea Tehnică a Moldovei

RAPORT
despre lucrarea de laborator Nr. 3
la Analiza și Proiectarea Algoritmilor în Python

A îndeplinit: Spac Antonio

TI-195

A verificat: Buldumac Oleg

Chişinău – 2021
Tema: Metoda divide et impera Scopul lucrării:
1. Studierea metodei divide et impera.
2. Analiza şi implementarea algoritmilor bazaţi pe metoda divide et
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
Algoritmul 1

import time
start = time.time()
def merge_sort(alist, start, end):
'''Sortam lista dupa inceputul indexarii incepind cu 1'''
if end - start > 1:
mid = (start + end) // 2
merge_sort(alist, start, mid)
merge_sort(alist, mid, end)
merge_list(alist, start, mid, end)

def merge_list(alist, start, mid, end):

left = alist[start:mid]
right = alist[mid:end]
k = start
i = 0
j = 0
while (start + i < mid and mid + j < end):
if (left[i] <= right[j]):
alist[k] = left[i]
i = i + 1
else:
alist[k] = right[j]
j = j + 1
k = k + 1
if start + i < mid:
while k < end:
alist[k] = left[i]
i = i + 1
k = k + 1
else:
while k < end:
alist[k] = right[j]
j = j + 1
k = k + 1

alist = input('Introduceti lista de numere: ').split()

alist = [int(x) for x in alist]
merge_sort(alist, 0, len(alist))
print('Lista sortata: ', end='')
print(alist)

end= time.time()
print(f"Timpul de executie a programului este de:{(end - start) / 1000}")
Rezultatele calcularii pentru 5 elemente
Timpul de executie: 0.007
Rezultatele calcularii pentru 10 elemente
Timpul de executie: 0.014
Rezultatele calcularii pentru 15 elemente
Timpul de executie: 0.021

Algoritmul 2

import time
start = time.time()
def quicksort(alist, start, end):

if end - start > 1:

p = partition(alist, start, end)
quicksort(alist, start, p)
quicksort(alist, p + 1, end)

def partition(alist, start, end):

pivot = alist[start]
i = start + 1
j = end - 1

while True:
while (i <= j and alist[i] <= pivot):
i = i + 1
while (i <= j and alist[j] >= pivot):
j = j - 1

if i <= j:
alist[i], alist[j] = alist[j], alist[i]
else:
alist[start], alist[j] = alist[j], alist[start]
return j

alist = input('Introduceti lista de numere: ').split()

alist = [int(x) for x in alist]
quicksort(alist, 0, len(alist))
print('Lista sortata: ', end='')
print(alist)

end= time.time()
print(f"Timpul de executie a programului este de:{(end - start) / 1000}")

Rezultatele calcularii pentru 5 elemente

Timpul de executie: 0.007
Rezultatele calculării pentru 10 elemente
Timpul de execuție: 0.019
Rezultatele calcularii pentru 15 elemente
Timpul de execuție: 0.025

Algoritmul 3
import time
start = time.time()
def bubble_sort(alist):
for i in range(len(alist) - 1, 0, -1):
no_swap = True
for j in range(0, i):
if alist[j + 1] < alist[j]:
alist[j], alist[j + 1] = alist[j + 1], alist[j]
no_swap = False
if no_swap:
return

alist = input('Introduceti lista: ').split()

alist = [int(x) for x in alist]
bubble_sort(alist)
print('Lista sortata: ', end='')
print(alist)

end= time.time()
print(f"Timpul de executie a programului este de:{(end - start) / 1000}")
Rezultatele calcularii pentru 5 elemente:
Timpul de execuție: 0.007
Rezultatele calcularii pentru 10 elemente
Timpul de execuție: 0.010
Rezultatele calcularii pentru 15 elemente
Timpul de execuție 0.010

Concluzie:
În cursul efectuării lucrării de laborator am descoperit că metoda Bubble Sort este cea mai
rapidă pentru un număr mai mare de elemente comparativ cu MergeSort și QuickSort.Al
doilea timp îl arată metoda QuickSort dar și ultimul MergeSort care are cel mai mare timp de
execuție în funcție de numărul de elemente introdus.