Ioana Neamt, u Structuri de Date

Laboratorul 8: Heap

1 Introducere

1.1 Heap

Heap-ul (movila) este o modalitate de a reprezenta arborii intr-o structura liniara,

folosind vectori astfel:

• pointerii catre nodurile fii sunt inlocuite cu indecsi, calculati folosind o formula de
calcul.

• pe prima pozitie din vector se va afla mereu radacina arborelui

1
Ioana Neamt, u Structuri de Date

1.1.1 Formule de calcul pentru indecsi

idx − 1
parent(idx) = (1)
2
lef t − son − index(idx) = 2 ∗ idx + 1 (2)

right − son − index(idx) = 2 ∗ idx + 2 (3)

Un min-heap binar este un arbore binar in care fiecare nod are propietatea ca
valoarea sa este mai sau egala decat a fiilor sai.

1.1.2 Inserarea unui nod in heap

• se adauga nodul pe ultima pozitie din vector

• daca valoarea nodului este mai mare decat cea a parintelui sau, se interschimba valoarea
nodului cu a parintelui, pana cand nodul ajunge in pozitia corecta (heapify up)

1.1.3 Stergerea nodului minim din heap

• nodul cu valoare minima este intodeauna radacina

• pentru a sterge acest element, se interschimba valoarea acestui nod cu valoarea ultim-
ului nod din lista si se elimina ultimul nod din lista

• daca valoarea noului nod radacina (x) este mai mare decat valoarea fiilor sai, se inter-
schimba cu valoarea cea mai mica dintre cele a fiilor. Procesul se continua pana cand
nodul x ajunge la pozitia corecta.

1.2 Arbori Huffman

Arborii Huffman sunt o metoda pentru compresarea textului, folosind un MinHeap.

Caracterelor le sunt atribuite coduri binare, astfel incat caracterele cele mai frecvente for

2
Ioana Neamt, u Structuri de Date

avea coduri formate din mai putine simboluri decat cele cu o frecventa mai redusa.

In figura de mai jos este un exemplu de arbore Huffman. Observati ca simbolurile

(literele) sunt memorate doar in nodurile frunze, iar ca un nod are ca valoare suma valorilor
fiilor sai.

1.2.1 Codificare

Algorithm 1 Huffman
0: procedure create-huffman-tree(data, freq)

1: huf f man − tree ← create − min − heap(data, f req, len(data))

2: while huffman-tree.size ¿ 1 do
3: lef t − child ← extract − min(huf f man − tree)
4: right − child ← extract − min(huf f man − tree)
5: new − node ← create − new − node(””, lef t− > f req + right− > f req)
6: insert − min − heap(huf f man − tree, new − node)
7: end while
8: return extract-min(huffman-tree)

Codificarea unui caracter, se obtine parcurgand arborele. Pentru fiecare muchie la

stanga parcursa se adauga 0, iar pentru fiecare muchie la dreapta se adauga 1.

In exemplul anterior, codul pentru ’e’ este 000 iar codul pentru ’a; este 010.

1.2.2 Decodificare

Pentru a decodifica, parcurgem arborele de codificare, iar pentru fiecare valoare 0

gasita, parcurgem pe ramura fiului stang, iar pentru fiecare valoare 1, parcurgem pe ramura
fiului drept.

3
Ioana Neamt, u Structuri de Date

2 Exercitii

Implementanti un MinHeap pentru codificarea Huffman.

typedef struct heap node {

char v a l u e ;
int f r e q ;
struct heap node ∗ l e f t , ∗ r i g h t ;
} heap node ;

typedef struct MinHeap {

// v e c t o r de p o i n t e r i l a n o d u r i
heap node ∗∗ v e c t o r ;
// numarul de n o d u r i d i n MinHeap
int s i z e ;
// c a p a c i t a t e a heap−u l u i
int c a p a c i t y ;
} MinHeap ;

// i n i t i a l i z a r e a heap−u l u i

4
Ioana Neamt, u Structuri de Date

MinHeap∗ c r e a t e m i n h e a p ( int i n i t i a l c a p a c i t y ) ;
// f u n c t i e u t i l i z a t a l a i n s e r a r e a i n MinHeap
void h e a p i f y u p ( MinHeap ∗heap , int pos ) ;
// f u n c t i e u t i l i z a t a l a s t e r g e r e a d i n MinHeap
void h e a p i fy d o w n ( MinHeap ∗heap , int pos ) ;
// f u n c t i e p e n t r u s t e r g e r e a n o d u l u i minim d i n heap
heap node ∗ e x t r a c t m i n ( MinHeap ∗ heap ) ;
// adaugarea unui nod i n heap
void i n s e r t ( MinHeap ∗heap , char value , int f r e q ) ;
// c r e a r e a a r b o r e l u i Huffman
heap node ∗ b u i l d h u f f m a n t r e e ( char data [ ] , int f r e q u e n c e s [ ] ) ;
// a f i s a r e a c o d u l u i p e n t r u un c a r a c t e r d a t a
void p r i n t c o d e ( MinHeap∗ h u f f m a n t r e e , char l e t t e r ) ;
// d e c o d i f i c a r e a unui cod
char decode ( MinHeap∗ h u f f m a n t r e e , char code [ ] ) ;

3 Link-uri utile

• MinHeap: https://www.cs.usfca.edu/ galles/visualization/Heap.html

• Huffman Tree: https://people.ok.ubc.ca/ylucet/DS/Huffman.html

4 Observatii

• Trimiteti laboratorul pe Moodle, in slotul grupei voastre pana astazi, ora 23:00.

• Laboratorul va fi trimis sub forma unei arhive zip continand toate fisierele sursă.