TEMA 9

Algoritmul de sortare HeapSort

În informatică, heapsort este un algoritm de sortare bazat pe

comparație. Heapsort poate fi considerat un algoritm de sortare prin
selecție îmbunătățit: la fel ca sortarea de selecție, heapsort își împarte
intrarea într-o regiune sortată și o regiune nesortată și micșorează
iterativ regiunea nesortată extragând cel mai mare element din acesta și
inserându-l în regiunea sortată. Spre deosebire de algoritmul de sortare
prin selecție, heapsort nu pierde timpul cu o scanare liniară a regiunii
nesortate; mai degrabă, sortarea heap menține regiunea nesortată într-
o structură de date heap pentru a găsi mai rapid cel mai mare element
din fiecare pas.
Deși oarecum mai lent în practică pe majoritatea sistemelor de
calcul decât un algoritm quicksort bine implementat, are avantajul unui
timp de execuție O (n log n) mai favorabil. Heapsort este un algoritm în
loc, dar nu este un tip stabil.

Prezentare generală

Heapsort a fost inventat de J. W. J. Williams în 1964. Aceasta a

fost și nașterea grămezii, prezentată deja de Williams ca o structură de
date utilă în sine. În același an, R. W. Floyd a publicat o versiune
îmbunătățită care ar putea sorta o matrice în loc, continuând
cercetările sale anterioare asupra algoritmului arbore.
Metoda de sortare prin selecţie directă se bazează pe selecţia
repetată a ultimei chei dintre n elemente, apoi dintre n-1 elemente
rămase, etc. Pentru a găsi cea mai mică cheie dintre n elemente sunt
necesare n-1 comparaţii, apoi găsirea următoarei dintre n-1 elemente
are nevoie de n-2 comparaţii, etc. ⇒ n(n-1)/2 comparaţii.
Această sortare se poate îmbunătăţi prin reţinerea, de la fiecare
scanare, de mai multă informaţie decât identificarea unui singur
element, cel mai mic. De exemplu, cu n/2 comparaţii se poate determina
cheia mai mică pentru fiecare pereche de elemente dintre cele n
elemente, apoi cu alte n/4 comparaţii se poate determina cheia cea mai

1 din 5 Profesor A.D.

mică pentru fiecare pereche ale cheilor determinate anterior, şi aşa mai
departe. Astfel, cu n-1 comparaţii se poate construi arborele de selecţie.

Descriem următorii paşi pentru o variantă de implementare a

algoritmului Heap sort(ordonare crescătoare):
1. presupunem că vectorul formează un arbore binar, fiecare poziţie
din vector reprezentând un nod, cu rădăcina pe poziţia 0(zero) şi
cu fiecare nod k având copiii 2k+1 şi 2k+2(dacă nu există poziţia
din vector cu indicele respectiv, atunci nu există nod copil ⇒
NULL)
2. formăm un max-heap cu aceeaşi reprezentare(pe vector, fără a
construi altă structură pentru noduri)
3. extragem maximul din rădăcina heap-ului(poziţia 0 din vector) şi
facem o intersschimbare între poziţia maximului şi ultima poziţie
din vector. Acum maximul se află pe poziţia dorită şi putem să-l
excludem din heap.
4. repetăm paşii(refacem forma de heap, extragem noul maxim,
reducem cu 1 numărul de elemente nesortate), cât timp mai sunt
elemente în heap.

Exemplu

În dorinţa de a îmbunătăţi algoritmul sortării pin selecţie (elementul

minim/maxim din vector se va aşeza în locul primului/ultimului element
al vectorului, algoritmul reluându-se pentru cele n-1 elemente rămase),
se pot face următoarele observaţii:
 fiecare algoritm de căutare a minimului/maximului dintre n
elemente, bazat pe compararea perechilor de elemente, trebuie
să facă cel puţin n-1 comparaţii (altfel, ar rămâne elemente
necomparate);
 observaţia anterioară se poate aplica doar primei etape de
căutare, ulterior putând folosi informaţii deja dobândite
(exemplu: pentru căutarea maximului din şirul 503, 87, 512, 61,
908, 170, 897, 275, putem împărţi şirul în patru subşiruri şi să
determinăm maximul din fiecare subşir: 503, 87 →503, apoi din
512, 61→521, din 908, 170→908, şi 897, 275→897, apoi
comparând doar elementele 503, 521, 908, 897 vom determina

2 din 5 Profesor A.D.

 maximul total, 908. Pentru a determina următorul maxim este
suficient să îl căutăm printre elementele rămase 503, 521, 897,
alături de 170 din grupul maximului anterior, reducând o serie
de comparaţii. Deci va fi 897, apoi alegem dintre 503, 521, 170,
275, etc. ).

Şirul valorilor anterioare poate fi organizat, după cum am

observat şi în exemplu, într-un arbore binar complet, pe nivelurile
superioare aşezând maximul a câte 2 valori ale nivelului anterior,
rădăcină ajungând maximul şirului. În etapa următoare, se înlocuieşte
maximul găsit anterior cu o valoare foarte mică, astfel încât printr-un
algoritm asemănător să obţinem maximul valorilor rămase, etc.

Pentru orice n se poate construi arborele binar complet cu n noduri

terminale. Un vector x cu n componente poate fi interpretat ca un
arbore binar. Mecanismul este următorul:
1. rădăcina este etichetată cu x[1];
2. nodul etichetat cu x[i] subordonează:
 la stânga nodul etichetat cu x[2*i], dacă 2*i≤n;
 la dreapta nodul etichetat cu x[2*i+1], dacă 2*i+1≤n.

Arborele binar complet asociat vectorului X: 5, 8, 2, 1, 9, 4, 3, 7, 6.

i 1 2 3 4 5 6 7 8 9

X[i] 5 8 2 1 9 4 3 7 6

Vom avea:
5
8 --- 2
1 --- 9 4 --- 3
7 --- 6

Definiţie:
Un MinHeap este un arbore binar complet cu proprietăţile:
1. informaţiile din noduri sunt valori dintr-o mulţime total
ordonată, numite chei;

3 din 5 Profesor A.D.

 2. pentru orice nod x[i], cheia memorată în x[i] este mai mică sau
egală cu cheia oricăruia dintre fii;
3. oricare ar fi i din mulţimea de indici{1, ... , [n/2]}, atunci
x[i]<=x[2*i] şi x[i]<=x[2*i+1], dacă 2*i+1<=n.

Observaţie:
În cazul arborelui reprezentat pentru un vector de tip MinHeap, orice
nod subordonează noduri cu etichete mai mari, iar în cazul vectorului
de tip MaxHeap, orice nod subordonează noduri cu etichete mai mici.

Algoritmul

Fiind dat un vector x cu n componente se cere ca acesta să fie

sortat crescător(descrescător) prin metoda Heap-urilor. Vom analiza
cazul sortării descrescătoare.
În cazul în care vectorul se organizează ca un MinHeap, este
evident că prima componentă reţine cea mai mică valoare (vezi şi
exemplul precedent), deci pentru ca vectorul să fie sortat descrescător
se organizează ca MinHeap, apoi se schimbă conţinuturile
componentelor 1 şi n, deoarece în acest caz, ultima componentă reţine
valoarea cea mai mare.
Din prima componentă şi MinHeap-urile cu vârfurile x[2] şi
x[3] se formează un nou MinHeap. Se interschimbă conţinuturile
componentelor 1 şi n-1.
...
Funcţia combinare formează un MinHeap dintr-un vârf şi două
MinHeapuri, iar funcţia heap organizează vectorul ca un MinHeap.

Varianta pseudocod a algoritmului:

subalgoritm combinare(vf, n)
baza, valoare, gata întreg;
baza←2*vf; valoare←x[vf];gata←0;
cât timp baza≤n şi gata=0 execută
dacă baza < n si x[baza] > x[baza+1] atunci baza←baza+1
sfârşit dacă;
dacă valoare>x[baza] atunci
x[vf]←x[baza]

4 din 5 Profesor A.D.

 vf←baza
baza←baza*2
altfel
gata←1
sfârşit dacă;
sfârşit cât timp;
x[vf]←valoare;
sfârşit combinare;
//**************************************
subalgoritm heap()
i intreg;
pentru i←n/2,1,-1 execută
combinare(i,n);
sfârşit pentru;
sfârşit heap;
//**************************************
subalgoritm heapsort()
aux,i întreg;
heap()
pentru i←n,2,-1 execută
aux←v[1]; v[1] ←v[i]; v[i] ←aux;
combinare(1,i-1);
sfârşit pentru;
sfârşit heapsort;

Metode de parcurgere a elementelor unei matrici

Cazul 1 Cazul 2 Cazul 3

Cazul 4 Cazul 5 Cazul 6

5 din 5 Profesor A.D.