ARBORI BALANSAI

(B-Trees)

 Arborii balansai sunt arbori de cutare

destinai s lucreze eficient pe discuri
magnetice; ei sunt realizai urmrind
aceleai idei i scopuri ca i arborii rounegrii dar sunt superiori acestora n
minimizarea timpului pentru intrare-ieire .

 Diferena esenial este c, n arborii

balansai, un nod poate avea mai muli
descendeni (pn la sute). Asemnarea
este c nlimea arborelui este O(log n)
dei baza logaritmului (mult mai mare) d
o nlime corespunzator mai mic.

 Se vede din figur cum arborii balansai

generalizeaz arborii binari de cutare.

 Cheile sunt consoane. Un nod conine n(x)

chei i are n(x) + 1 descendeni. Toate
frunzele au aceeai adancime. Nodurile
albe marchez drumul pentru cutarea
literei R.

 Avem la dispoziie multe tehnologii de

memorare a datelor. Memoria principal
este realizat pe cipuri de siliciu. Aceast
memorie a crescut i s-a ieftinit de-a
lungul timpului, totui ea rmne mai mic
i mai scump dect memoria pe medii
magnetice dei mult mai rapid.

 Timpul unor operaii pe calculator ce

includ citiri i scrieri pe disc depind de:
- numarul de accese la disc
- timpul de lucru al procesorului.

 Folosim arbori balansai n aplicaii n care

datele nu pot intra n memoria Principal.
Algoritmii coninui n acest capitol copiaz
anumite pagini de memorie de pe disc n
memoria principal i, pe cele care s-au
modificat, le rescrie (napoi pe disc).
Modelul, din acest punct de vedere, este
urmtorul:


Fie x un pointer ctre un obiect. Dac obiectul
se afl n memoria principal, ne vom referi la
cmpuri ca de obicei (ex.KEY(x)). Dac obiectul
se afl pe disc, vom face mai nti o operaie de
citire CIT_DISK(x) a obiectului x i apoi ne
putem referi la cmpurile lui. Dac s-au efectuat
modificri ale cmpurilor lui x ele vor fi
actualizate pe disc prin scriere SCR_DISK(x).

 Ca s micorm numrul de accese la

disc trebuie s mrim dimensiunea
nodului. n general un nod va fi memorat
pe o pagin ntreag. Aceasta nseamn
un factor de ramificare ntre 50 i 2000.

Definiia arborilor balansai.

Un arbore balansat T este un arbore cu rdcina Rad(T)
cu urmtoarele proprieti :
1.Fiecare nod are urmtoarele cmpuri:
a) n( x) numarul de chei de stocate n x
b) cele n( x) chei memorate n ordine cresctoare
KEY1(x),KEY2(x),...,KEYn(x)(x).
c)F(x) cu valoare adevarat daca x este frunz i fals
dac x nu
d) Dac x este nod intern atunci x mai conine n(x)+ 1
pointeri Cl(X),C2(X) ,... ,Cn(x)+l(X) la copiii lui x

 2.Cheile din x separ cheile din

descendeni adic dac kj este o cheie
oarecare din descendentul de la adresa
Cj( x) cu j{1,2,...,n( x)+ 1} atunci:
k1KEY1(x)k2KEY2(X) ... KEY n(x)
(x)kn(x)+l
3.Fiecare frunz are aceeai adncime
care este nlimea arborelui.

 4.Exist un numr maxim i un numr minim de chei

pe care le poate conine un nod care sunt n legtur
cu t 2 numit gradul minim al lui T.
a)Fiecare nod, n afar de rdcin, are cel puin t-1
chei i deci, dac este intern, are cel puin t
descendeni. Dac arborele este nevid, rdcina
trebuie s aib cel puin o cheie .
b)Fiecare nod poate conine cel mult 2t-1 chei (un
nod intern are cel mult 2t descendeni). Spunem ca
un nod este plin, dac are exact 2t-1 chei.

 Cel mai simplu arbore balansat este cu t =

2 unde fiecare nod poate avea 2, 3 sau 4
descendeni.

nlimea unui arbore balansat.

Teorema
Dac n1 este numrul de chei dintr-un
arbore balansat cu nlimea h i gradul
minim t 2 atunci h logt ((n+1)/2).
Demonstraie.

O s pornim n demonstraie de la un
arbore cu numr maxim de chei ca n
exemplul urmtor.

 Dac arborele are nlimea h, atunci

numrul de noduri este minim cnd
rdcina conine o cheie i celelalte noduri
conin t-1 chei. n acest caz sunt 2 noduri
la primul nivel, 2t la al doilea nivel, i aa
mai departe pn la nivelul h unde sunt
2th-1.

Operaii n arbori balansai.

Pentru urmtorii algoritmi vom presupune
c rdcina arborelui este n memoria
principal, deci nu avem CIT_DISK pentru
ea, dar este nevoie de SCR_DISK dac
avem actualizri ale cmpurilor rdcinii.
Mai presupnem c orice alt nod are nevoie
s fie citit ca s avem acces la cmpurile
lui.

Cutarea n arborii balansai.

Algoritmul este recursiv i se apeleaz
prima dat cu B_TREE_CAUT(Rad(T), k
,rez), unde k este cheia cautat, rez
conine rezultatul cutrii adic perechea
(y,i) care nseamn c nodul y are a i-a
cheie KEY(y)=k sau rez=Nil dac cheia nu
este n arbore.

B- TREE- CAUT( x,k,rez)

i=l
att timp cat i<n(x) i k> KEYi(x)
i=i+l
Sciclu
Daca in(x) i k = KEYi(x) atunci
rez = (x, i)
return
sdaca
Daca Frunza(x) atunci
rez = Nil
Return
altfel
Cheama CIT_DISK(ci(x))
Cheama B_TREE_CAUT(ci(x), k, rez)
return
sdaca

Construcia unui arbore

balansat.
Pentru aceasta vom creea mai nti un
arbore vid i vom insera pe rnd n el noile
chei. Avem nevoie mereu de locuri libere
pe disc pe care le fumizeaz
ALOC_NOD().

B_TREE_CRE(T)
x = ALOC_NOD( )
Frunza(x) = True
n(x) = 0
SCR_DISK(x)
Rad(T) = x
Return

 Dac un nod este plin, ca s putem insera

n continuare, el trebuie rupt n dou, ca n
figur

 Nodul plin are 2t - 1 chei i cheia din

mijloc (indice t) se duce n printe,
presupus neplin.
Dac se face ruperea rdcinii atunci
arborele crete n nlime cu 1. Procedura
B_TREE_RUP are ca intrare un nod intern
neplin - x (aflat deja n memoria
principal), un index - i i un nod y = c i(x)
care este un descendent plin al lui x.

B_TREE_RUP(x, k, y)
z = ALOC_NOD( )
Frunza(z) = Frunza(y)
n(z) = t-1
Pentru i = 1, t-1
KEYi(z) = KEYi + t(y)
spentru
Daca nu Frunza(y) atunci
Pentru i=1,t
Ci(z) = Ci+t(z)
spentru
sdaca
n(y) = t-1
Pentru i = n(x)+1,k+l,-1
Ci+l(X) = Ci(x)
spentru

Ci+l(X)= z
Pentru i = n(x), k, -1
KEYi+l(X) = KEYi(x)
spentru
KEYk(x)=KEY t(y)
n(x) = n(x) +1
SCR_D ISK( x)
SCR_DISK(y)
SCR_DISK(z)
return

Inserarea n arborii balansai

Putem s construim acum inserarea care
ncepe cu cazul n care rdcina este
plin exemplificat n figur

Cheia k trebuie inserat n arborele

T, la locul ei.

B-TREE_INSERT(T, k)
r=Rad(T)
daca n(r) = 2t-1 atunci
s = ALOC_NOD( )
Rad(T) = s
Frunza(T) = False
n(s) = 0
cl(S) = r
cheama B_TREE_RUP(s, 1, r)
cheama B_TREE_INS_NEPLIN(s,k)
altfel
cheama B- TREE_INS_NEPLIN (r,k)
Sdaca
Return

 Procedura B_TREE_INS_NEPLIN
parcurge arborele n jos pn la locul
unde trebuie fcut inserarea.

B- TREE_INS_NEPLIN(x, k)
i = n(x)
Daca Frunza(x) atunci
atata timp cat i 1 i k<KEYi(x)
KEYi+1(x) = KEYi(x)
i=i-1
Sciclu
KEYi+1(X) = k
n(x) = n(x) + 1
SCR_DISK(x)
atata timp cat i 1 i k<KEYi(x)
i=i-1
sciclu
i=i+l
CIT_DISK(ci(x))

Daca n(ci(x))=2t-l atunci

Cheama B_TREE_RUP(x,i,ci(x))
Daca k> KEYi( x) atunci
i=i+ 1
sdaca
sdaca
Cheama B_TREE_INS_NEPLIN(ci(x), k)
return

Exemple de inserri

tergerea unei chei dintr-un

arbore balansat
Aceasta este o operaie similar cu
inserarea, dar ceva mai complicat.
B_TREE_STERG(x, k) terge din
subarborele T ncepnd n nodul x, cheia
k. Grija este ca numrul de chei din
nodurile parcurse (altul dect rdcin) s
fie t (gradul minim), adic cu 1 mai mult
dect de obicei ca s putem terge o
cheie.

 Aa c, uneori, o anumit cheie trebuie s

coboare ntr-un nod descendent nainte de
a-l parcurge. Dac n acest mod rdcina
x rmne fr chei atunci singurul
descendent ci(x) va fi noua rdcin i x
dispare, micornd astfel nalimea
arborelui cu 1.

(e) tergerea lui B : cazul 3a