Structuri de date

Acest capitol se referă la niște structuri de date ceva mai complexe decât cele obișnuite din
programare (vectori și matrice).
Cele mai simple sunt stiva (stack) și coada (queue) care au organizare liniară.
Unele puțin mai complicate sunt Arborii Binari de Căutare și Arborii Binari de tip Heap (care
se mai numesc și Priority Queue).

În toate aceste structuri de date definim operațiile:

PUSH(X) = în structura de date se adaugă o nouă valoare
POP(X) = din structura de date se șterge o valoare și acea valoare o ia X.. Dacă structura
este vidă, se consideră că X ia valoarea NIL.

STIVA (Stack) = funcționează ca o stivă de obiecte - adică puse unele peste altele.
Are comportament de tip LIFO (Last Input First Output - ultimul care a intrat este primul care
iese).
Astfel, orice operație PUSH pune valoarea PESTE cele deja existente. Orice operație POP ia
valoarea din vârful stivei și o șterge.
Iată cum se comportă o stivă inițial vidă, dacă facem operațiile următoare:
PUSH(A), PUSH(M), PUSH(E), POP(X), PUSH(R), POP(X),
PUSH(I), POP(X), POP(X), POP(X), POP(X), PUSH(C), PUSH(A), PUSH(N)
Operația Stiva
Inițial Stiva este vidă

PUSH(A)
A

PUSH(M)
M
A

PUSH(E)
E
M
A

POP(X)
Scoate X=E și îl și șterge din M
stivă A

PUSH(R)
R
M
A
 POP(X)
X=R M
A

PUSH(I)
I
M
A

POP(X)
X=I M
A

POP(X)
X=M A

POP(X)
X=A

POP(X)
X=NIL

PUSH(C)
C

PUSH(A)
A
C
PUSH(N)
N
A
C

COADA (Queue) = funcționează ca o coadă civilizată în care cei care intră se așază după cei
care există deja la coadă și cei care pleacă ies din cealaltă parte.
Are comportament de tip FIFO (First Input First Output - primul, deci cel mai de demult care a
intrat este primul care iese).
De regulă, orice operație PUSH pune valoarea nouă la dreapta celor deja existente. Orice
operație POP ia valoarea din stânga cozii și o șterge.
Iată cum se comportă o coadă inițial vidă, dacă facem operațiile următoare:
PUSH(A), PUSH(M), PUSH(E), POP(X), PUSH(R), POP(X),
PUSH(I), POP(X), POP(X), POP(X), POP(X), PUSH(C), PUSH(A), PUSH(N)
Operația Coada
Inițial Coada este vidă
PUSH(A)
A

PUSH(M)
A M

PUSH(E)
A M E

POP(X)
Scoate X=A și îl și șterge din M E
coadă
PUSH(R)
M E R

POP(X)
X=M E R

PUSH(I)
E R I

POP(X)
X=E R I

POP(X)
X=R I

POP(X)
X=I

POP(X)
X=NIL

PUSH(C)
C

PUSH(A)
C A

PUSH(N)
C A N
Arborii binari de căutare (Binary Search Tree)
Sunt arbori binari, adică fiecare nod are maxim 2 fii, cu următoarea proprietate
· Orice nod este mai mare sau egal cu fiul său din stânga și STRICT mai mic decât fiul său
din dreapta.

Construcția BST-ului se face punând prima valoare dată în rădăcină și apoi pentru fiecare
valoare nouă se parcurge BST-ul plecând de la rădăcină, mergând pe stânga dacă valoarea
de inserat este mai mică sau egală, respectiv mergând pe dreapta dacă valoarea de inserat
este mai mare. În primul loc găsit liber, inserăm efectiv valoarea.
Să vedem cum se construiește un BST din literele A, M, E, R, I, C, A, N:

Operația ARBORELE
Inițial Vid
PUSH(A)
PUSH(M
)

PUSH(E)

PUSH(R)

PUSH(I)

PUSH(C)

PUSH(A)

PUSH(N)
DECI BST-ul final este:

Se poate cere:
- să-l parcurgem:
· Preordine (RSD): A A M E C I R N
· Inordine (SRD): A A C E I M N R (obs: dacă parcurgem BST în inordine, noduril ies în
ordine
crescătoare - sortate)
· Postordine (SDR): A C I E N R M A

Înălțimea (sau adâncimea = depth) unui arbore este dat de numărul de niveluri minus 1. La
noi sunt 4 niveluri (nivelul 0 - pe care este rădăcina, nivelul 1 pe care sunt A,M, nivelul 2 pe
care sunt E și R, nivelul 3 pe care cunt C, I, N)

Analog, adâncimea unui nod este dată de numărul nivelului pe care se află el (în indeea că
rădăcina este pe nivelul 0).

Definim "Internal path length" (lungimea căii interne) ca fiind suma adâncimilor tuturor
nodurilor.
La noi:

Numim "noduri externe" locurile libere disponibile la nodurile din arborele nostru, în care mai
pot fi adăugate niște noduri.
Suma tuturor adâncimilor nodurilor externe se numește "external path length":
Ștergerea unui nod din BST

Dacă nodul este frunză, e cel mai simplu: pur și simplu îl ștergem.
Dacă nodul pe care vrem să-l ștergem are un singur fiu, doar ștergem acest fiu și legătura o
facem către fiul acestuia.

Dacă vrem să ștergem un nod care are 2 fii, e puțin mai complicat:
- fie X = nodul de șters, ST=subarborele stâng, DR = subarborele drept.
Pur și simplu ducem ST în locul lui X, iar DR se leagă de cel mai din dreapta fiu al lui ST-ul
proaspăt adăugat.

Exemplu: Din acest arbore vrem să-l ștergem pe M:

Deci
· îl ștergem pe M
· aducem în locul lui subarborele care are rădăcina la E:

=> =>
Arborele final:

Temă: De rezolvat următoarele 2 exerciții: