Curs 2

 Structuri de date avansate pentru cautare

2-3 arbori
B-arbori
arbori bicolori
Tabele hash
Arbori digitali
 2-3-arbori: definitie

 orice nod intern v are 2 copii (este de aritate 2) sau 3 copii

(este de aritate 3)

valStg valStg valMij

p->stg p->mij p->drp

subarbore subarbore subarbore

stanga mijlociu dreapta
 2-3-arbori : definitie

 pentru orice nod v de aritate 2, valorile memorate in

subarborele stinga < vvalStg < valorile memorate in
subarborele mijlociu

valStg

x < valStg valStg < y

 2-3-arbori : definitie

 pentru orice nod v de aritate 3, valorile memorate in subarborele

stinga < vvalStg < valorile memorate in subarborele
mijlociu < vvalMijl < valorile memorate in subarborele
dreapta

valStg valMij

valStg<
x< valStg y< valMij<z
valMij
 2-3-arbori : definitie

 toate nodurile de pe frontiera au acelasi nivel

h
h
 cautare in 2-3-arbore

function poz23Arb(t, a)
begin
p  t
while (p != NULL) do
switch(cmp(a, p))
case 1: p  p->stg; break;
case 2: p  p->mij; break;
case 3: p  p->drp; break;
case 4: return p;
return p
end
 inserare in 2-3-arbore
35 80; 

30; 60 100; 

10; 20 40; 50 70;  90;  110; 120

80; 

30; 60 100; 
40
10; 20 35;  50;  70;  90;  110; 120
 inserare 2-3-arbore (continuare)

80; 
40
30;  60;  100; 

10; 20 35;  50;  70;  90;  110; 120

40; 80

30;  60;  100; 

10; 20 35;  50;  70;  90;  110; 120

 inserare 2-3-arbore (continuare)

 subprograme necesare
 radNoua(t, x, q)
• creeaza o noua radacina cu cheia x
t: intrare – rad subarb. stg.
iesire – noua rad.
q rad. subarb. drp
 poz23ArbMod(t, x, s)
• memoreaza drumul de la radacina la x in stiva s
 insInNod(p, x, q)
• insereaza x innodul p
parametri sunt similari subprogramului radNoua()
 imparte(p, x, q)
• sparge un nod
parametri sunt similari subprogramului insInNod()
 inserare 2-3-arbore (continuare)

procedure ins23Arb(t, x)
begin
if (t == NULL) then radNoua(t, x, NULL)
else p = poz23ArbMod(t, x, s)
if (p == NULL) then throw ”x in t”
else q  NULL
while(true) do
if (p->valMij = )
then insInNod(p, x, q); break
imparte(p, x, q)
if (p = t)
then radNoua(t, x, q); break;
else p = top(s);
pop(s);
end
 stergere 2-3-arbore

 daca elemntul sters nu se afla intr-un de pe frontiera, atunci se

poate interschimba cu un vecin aflat pe frontiera

 vecinul cu care face interschimbarea se poate face ca la

arborii binari de cautare

 asa ca putem considera numai cazul cand elementul care se

sterge se afla pe frontiera
 stergere 2-3-arbore
40; 80

30;  60;  100; 

10; 20 35;  50;  70;  90;  110; 120

40; 80

30;  100; 

10; 20 35;  50; 60 90;  110; 120

 stergere 2-3-arbore: combinare

combina 40; 80

30;  100; 

10; 20 35;  50; 60 90;  110; 120

80; 

30; 40 100; 

10; 20 35;  50; 60 90;  110; 120

 stergere 2-3-arbore: rotatie
50; 80
roteste dreapta

30; 40 60;  100; 

40; 80

30;  50;  100; 

 stergere 2-3-arbore

 modifica p
 atat timp cat p are zero elemente && p nu e radacina
 fie r radacina lui p
 fie q fratele lui p (stg. sau drp. dupa caz)
 daca q este de aritate 3
atunci roteste
altfel combina
r devine p

 Exercitiu: Sa se scrie procedura de stergere

 Teorema
Clasa 2-3-arborilor este O(log n)-stabila.
 2-3-4-arbori

 sunt generalizari ale 2-3 arborilor

 un nod intern poate avea 2, 3 sau 4 copii
 un nod cu 4 copiii va memora 3 chei
 se mentin proprietatile de arbore de cautare si aceeasi inltime
pentru toate nodurile de pe frontiera
 ca si in cazul celorlalti abori de cautare, exista doua moduri de
implementare:
 elementele multimii memorate in nodurile interne (si frunze)
 elementele multimii doar in nodurile frunza (pe frontiera)
 inserarea se face tot prin spargerea nodurilor
 la momentul inserarii si propgarea spre radacina
 sau in timpul cautarii, fiecare nod plin este spart in doua
 Arbori de cautare pe M-cai

 generalizare de la 2-3 si 2-3-4 la M

 un nod poate avea n copii cu 2 <= n <= M
 numarul de chei memorate intr-un nod este n-1; cheile k1,..., kn-1
sunt ordonate crescator
 are proprietatea de arbore de cautare:
 elementele memorate in subarborele Ti sunt mai mici decat
cheia ki
 elementele memorate in subarborele Ti+1 sunt mai mari decat
cheia ki
 B-arbori - motivatie

 Un index ordonat este un fisier secvential. Pe masura ce

dimensiunea acestuia creste, cresc si dificultatile de administrare
 un acces la disc este mult mai scump decat executia unei
instructiuni ( 200,000 instructiuni)
 memoria secundara (discul) este divizata in blocuri egale (512,
1024, 2048 etc)
 o operatie I/O transfera un bloc
 scopul este de a minimiza numarul de accesari ale discului
 Solutia: indexarea pe mai multe nivele .
 un posibil instrument : B arborii (arbori de cautare multicai)
Organizarea pe nivele a indexului
 B-arbori

 sunt arbori de cautare pe M-cai cu proprietati

 presupunem ca M = 2f
• f = factorul de minimizare
• ordinul arborelui este 2f-1
 fiecare nod intern are cel putin un numar de f-1 chei (f fii) si
cel mult 2f-1 chei (2f fii)
 doar radacina poate avea mai putin de f fii
 lungimea oricarui drum de la radacina la o frunza trebuie sa
fie aceeasi (generalizeza 2-3 si 2-3-4 arborii)
B-arbore: structura unui nod
 Optimizarea accesului la disc

 Daca fiecare nod necesita accesarea discului atunci B-arborii vor

necesita numar minim de astfel de accesari

 Factorul de minimizare va fi ales astfel incat dimensiunea unui

nod sa corespunda unui multiplu de blocuri ale dispozitivului de
memorare

 Aceasta alegere optimizeaza accesarea discului

 Inaltimea h a unui B-arbore cu n > 0 chei si f > 1 este

h <= logf[(n+1)/2]
 B-arbori: cautarea

function B-Tree-Search(v, k)
i  0;
while (i < v->nrChei  k > v->cheie[i]) do
i  i + 1
if (i <= v->nrChei  k = v->cheie[i] )
then return (v, i)
if (v->tipNod = frunza) then return NULL
citesteDisk(v->fiu[i])
return B-Tree-Search(v->fiu[i], k)
end
 B-arbori: insertia

 Pentru a efectua o insertie intr-un B-arbore trebuie intai gasit

nodul in care urmeaza a se face insertia.
 Pentru aceasta se aplica un algoritm similar cu BTree-
Search.
 Apoi cheia urmeaza a fi inserata
 Daca nodul determinat anterior contine mai putin de 2f-
1chei se face inserarea
 Daca acest nod contine 2f-1 chei urmeaza spargerea acestuia
• Procesul de spargere poate continua pana in radacina
• Pentru a evita doua citiri de pe disc ale aceluiasi nod,
algoritmul sparge fiecare nod plin (2f-1 chei) intalnit la
parcurgea top-down in procesul de cautare a nodului in
care urmeaza a se face inserarea
 Timpul de spargere a unui nod este O(f)
 Rezulta pentru insertia complexitatea timp O(f log n)
 B-arbori: eliminarea

 daca nodul gazda a cheii ce urmeaza a fi stearsa nu este frunza,

atunci se efectueaza o interschimbare intre acesta si succesorul
sau in ordinea naturala a cheilor. Se repeta operatia pana se ajunge
intr-o frunza, care devine nod curent;
 se sterge intrarea corespunzatoare cheii;
 daca nodul curent contine cel putin f-1 chei, operatia de stergere
se considera terminata;
 daca nodul curent contine mai putin decat f-1 chei se considera
fratii vecini;
 daca unul din fratii vecin are mai mult decat f-1 chei, atunci se
redistribuie una dintre intrarile acestui frate in nodul parinte si
una din intrarile din nodul parinte se redistribuie nodului
curent (deficitar);
 daca ambii fratii au exact f-1 chei, atunci se uneste nodul
curent cu unul dintre fratii vecini si cu o intrare din parinte;
 daca nodul parinte devine deficitar (contine mai putin decat f-
1 chei) acesta devine nod curent si se reiau pasii 5-6.
 Arbori bicolori

 un arbore bicolor este caracterizat de urmatoarele proprietati:

sint arbori binari de cautare in care nodurile pendante
(coresp. intervalelor) fac parte din structura
fiecare nod este colorat cu negru sau rosu
toate nodurile de pe frontiera sint negre
daca un nod este rosu atunci ambii fii ai acelui nod sint
negri
pentru orice nod v, toate drumurile simple care pleaca din
acel nod si se opresc intr-un nod de pe frontiera, au
acelasi numar de noduri negre
 Exemplu de arbore bicolor

70

40 100

20 60 80 110

50 90
 arbori bicolori - proprietati
Notatie
bh(x) = numarul de noduri negre aflate pe un drum din x pe
frontiera (x nu se considera)
bh(x) nu depinde de drum (ultima conditie)
Lema
Subarborele cu radacina in x contine cel putin

2 bh( x )
1
noduri interne.

Teorema
Inaltimea unui arbore bicolor este cel mult 2log(n + 1).

Teorema
Arborii bicolori sint echilibrati.
 arbori bicolori - inserare

11

2 14

1 7 unchiul lui x 15

5 8 y
x 4

recolorare
 arbori bicolori - inserare

11
unchiul lui x

2 14 y

1 7 x 15
5 8

4
roteste stanga
 arbori bicolori - inserare

11
unchiul lui x

7 14 y

x 2 8 15
1 5

4
roteste dreapta
 arbori bicolori - inserare

2 11

1 5 8 14

15
4
recoloreaza
 arbori bicolori - inserare

2 11

1 5 8 14

15
4
 Hashing (dispersie)
 Tipul de data abstract TabelaDeSimboluri
entitati de tip data: o colectie de perechi (nume, atribute)
in care numele identifica unic perechea
operatii:
• Atribut(TS, nume) – cauta numele in tabela TS
numele nume si intoarce atributele acestuia (daca il
gaseste)
• Insereaza(TS, nume, atribut)- insereaza
in tabela TS perechea (nume, atribut)
• Elimina(TS,nume) – cauta in tabela TS numele
nume si daca-l gaseste il elimina impreuna cu
atributele sale.
 Hashing (dispersie)

 Implementarea prin tehnica dispersiei

structura de date
• o tabela (hash sau de dispersie) T[0..p-1] cu p
numar prim de obicei
• o functie hash h: mult. numelor  [0..p-1]
 Hashing (continuare I)

operatii
• cautarea
i = h(nume)
if (T[i]  )
then return T[i]->atrib
• inserarea
i = h(nume)
if (T[i]  )
then throw “ERR: coliziune”
else T[i]->atrib  atribut
• eliminarea
i = h(nume)
if (T[i]  )
then T[i]  
 Hashing (continuare II)

 Alegerea functiei hash

 h(x) = x % p
 h(64747488289) = (647+4748+8289)%p
 daca x este sir:
unsigned hashVal=0;
while (*x != „\0‟)
hashVal = (hashVal << 5) + *x++;
return hashVal % p
 Hashing (continuare III)

 coliziunea
inlantuire
• numarul mediu de comparatii in cazul cautarilor cu
succes = 1 + b/2, unde b = #S/p este factorul de
incarcare al tabelei
adresare deschisa liniara
• se cerceteaza pe rind pozitiile
h(x,i), i = 0,1,2, ...
unde h(x,i) =(h1(x)+i) % p
• numarul mediu de comparatii in cazul cautarilor
FARA succes = 1/(1-b)
• numarul mediu de comparatii in cazul cautarilor CU
succes = ½(1 + 1/(1-b))
 Arbori digitali - I

Cazul cheilor de aceeasi lungime

S = {102, 120, 121, 210, 211, 212}
 Arbori digitali - II

 algoritmul de cautare

function poz(a, m, t)
i  0
p  t
while ((p != NUL) && (i<m)) do
p  succ[a[i]]
i  i+1
return p
end
 Arbori digitali - III

 Cazul cheilor de lungime diferita

 Arbori digitali - IV

 compactarea lanturilor
 Arbori digitali - V

 Inserarea lui 0111 in structura compactata

 Arbori digitali - VI

 Eliminarea lui 1011 in structura compactata