Sunteți pe pagina 1din 9

Lucrarea de laborator nr 5

Arbori Binari Optimali de Cautare

1.Prezentare generala

Un arbore binar de cutare optim este un arbore binar de cutare pentru care nodurile
sunt aranjate pe acelasi nivel astfel incat costul este minim. n scopul pentru o mai buna
prezentare de arbori optimi de cutare binar, vom lua n considerare sintagma urmatoare
"arbori extinsi binari de cutare", care au cheile stocate la nodurile lor interne. S presupunem
c "n" chei k1, k2, ..., n k sunt stocate la nodurile interne ale unui arbore binar de cutare. Se
presupune c cheile sunt date n ordine sortat, astfel nct k1 <k2 <... kn <. Un arbore binar de
cutare extins este obinut din arborele binar de cutare prin adugarea de noduri succesor
pentru fiecare dintre nodurile terminale sale cum este indicat n figura urmtoare cu ptratele:

a) Arbore binary de cautare b) arbore binary de cautare extins

ntr-un arbore binar extins avem:-

-ptratele reprezint nodurile terminale. Aceste noduri terminale reprezint cutrile nereuite
de arbore pentru valori cheie. Cautarea nu s-a sfrit cu succes, deoarece acestea reprezint
valorile cheie nu se afla in arborele de cautare al fiecarui nod care este parcurs in acelasi timp;
- nodurile rotunjite reprezint nodurile interne, acestea sunt cheile reale stocate n arbore;
- presupunnd c frecvena relativ cu care fiecare valoare cheie este accesata este cunoscuta,
greuti pot fi atribuite la fiecare nod al arborelui extins (P1 ... P6). Ele reprezint relativ
frecvenele de cutri de ncheiere la fiecare nod, care sunt marcate ca drept cutri de succes.
Dac utilizatorul caut o cheie speciala n arbore, 2 cazuri pot s apar:
-Cazul 1 - cheie este gasit, deci "p" de greutate corespunztoare este incrementat;
- Cazul 2 - cheia nu este gsit, aa corespunztoare "Q" valoare este incrementat.

n general, in anticiparea cuvntului apare problema de a ghici cuvntul urmtor ntr-o


propoziie i actualizarea aceastei predicii ca i cand cuvntul ar fi tastat. n prezent,
"anticiparea cuvntului" implic att gasirea cuvntului cat i anticiparea cuvntului. Cuvantul
finalizare este definit ca oferind utilizatorului o list de cuvinte dup o scriere ce a fost
introdusa, n timp ce anticiparea cuvntului este definita ca oferind utilizatorului o list de
cuvinte probabile dup un cuvnt care fost introdus sau selectat, bazate pe cuvinte anterioare,
mai degrab dect pe baza scrisorii intrei cautate pe parcurs. Problema de finalizare este mai
uor de rezolvat, deoarece cunoaterea unor litere ofer o ans predictorie de a cunoaste si de
a elimina mai multe cuvinte irelevante in arborele ce cautare. Dicionarele online se bazeaza
puternic pe facilitile oferite de arbori de cutare optim. Ca de dicionar mai muli utilizatori
i mai mult, este capabil de a atribui greuti la cuvintele corespunztoare, n funcie de
frecvena de lor de cutare. n acest fel, ea va fi n msur s ofere un rspuns mult mai rapid,
iar timpul de cutare scade n mod dramatic atunci cand cuvintele stocate ntr-un arbore binar
de cutare.De exemplu, atunci cnd ncepei s tastai o interogare de cutare in casete de
cautare Google, o list de intrri posibile apare aproape instantaneu.

Generalizarea: nod terminal din arborele extins, care este succesorul de stnga k1 poate fi
interpretat ca reprezentnd toate valorile cheie care nu sunt stocate i sunt mai puin de K1. n
mod similar, terminalul nod n arborele de extins, care este succesorul de drept kn, reprezint
cheia nu toate valorile stocate n copac care sunt mai mari dect kn. nodul terminal care este
reusesti ntre ki i ki-1 ntr-o traversare in ordine reprezint toate cheile care nu au valori
stocate care se afl ntre ki i ki-1. n arborele extins din figura de mai sus n cazul n care
valorile posibile cheie sunt 0, 1, 2, 3, ..., 100 apoi nod terminal etichetat q0 reprezinta valorilor
lips tasta 0, 1 i 2, n cazul n care k1 = 3; nod terminal etichetat Q3 reprezint valorile
eseniale ntre K3 i K4. Dac K3 i K4 = 17 = 21, atunci nodul terminal etichetat Q3 reprezint
valorilor lips cheie 18, 19 i 20. Dac K6 este de 90 apoi de la nodul terminal q6 reprezint
lips Valorile-cheie 91, prin 100. Un mod evident pentru a gsi un arbore binar de cutare
optim este de a genera fiecare arbore binar de cutare este posibil pentru tastele, calcula
durata calea ponderate, i s pstreze acel arbore cu cea mai mic lungime de cale ponderata.
Acesta cauta prin toate soluiile posibile nu este fezabil, deoarece numrul de arbori, cum ar
creste exponential cu "n".O alternativ ar fi un algoritm recursiv. Luai n considerare
caracteristicile vreun copac optime. Desigur, are o rdcin i doi subarbori. Ambii subarbori
trebuie s se fi optimal arbori binari de cutare cu n ceea ce privete cheile i greuti. n
primul rnd, orice subarbore de orice arbore binar de cutare trebuie s fie un arbore binar de
cutare. n al doilea rnd, subarbori trebuie s fie, de asemenea, optim.Deoarece exist "n"
cheile posibile n calitate de candidai pentru rdcin de copac optime, soluia
recursivetrebuie s ncercai-le pe toate. Pentru fiecare cheie candidat ca root, toate cheile mai
mic dect cea cheie trebuie s apar n subarborele sale stnga n timp ce toate cheile mai
mare dect aceasta trebuie s apar n subarborele ei drept. Preciznd algoritm recursiv pe
baza acestor observaii avem nevoie de unele notaii:

Obst (i, j) denot arbore optim de cutare binare care conine cheile ki, ki +1, ..., kJ;
Wi, denot j greutate matricea pentru Obst (i, j);
Wi, j poate fi definit utiliznd urmtoarea formul;
Wij = pk + qk, i=1 < j
Ci, j, 0 ijn denot cost matrice pentru Obst (i, j);
Ci, j pot fi definite recursiv, n modul urmtor;
Ci, i = Wi, j;
Ci, j = Wi, j + mini<k_j(Ci, k - 1 + Ck, j);
Ri, j, 0 ijn denot rdcin matrice pentru Obst (i, j);
Atribuirea notaia Ri, j la valoarea de k pentru care se obtine un minim n cele de mai sus
relaiilor, arbore binar de cutare optim este Obst (0, n) i fiecare Obst subarbore (i, j) a
root kRij i ca subarbori copacii notat cu Obst (i, k-1) i Obst (k, j).
Obst (i, j) va implica greutile qi-1, pi, qi, ..., pj qj;

Toate subarbori posibil optime nu sunt necesare. Cei care sunt constau din secvene de
taste pe care suntsuccesorii imediat de cele mai mici cheie n subarborele, succesorii n ordinea
sortate pentru chei.Abordarea de jos n sus genereaz toate cel mai mic subarbori necesar optim
n primul rnd, apoi toate urmtoarea cea mai mic,i aa mai departe pn la soluia final care
s implice toate greutile este gsit. Avnd n vedere c algoritmul necesit acces laLungimea
fiecare subarbore lui cale ponderate, aceste lungimi ponderat trasa trebuie s fie, de asemenea,
pstrate pentru a evita lorrecalculare. Acestea vor fi stocate n greutate "W" matrice. n cele din
urm, rdcina fiecrui subarbore trebuie s fie, de asemenea,stocate pentru referin n rdcina
"R" matrice.

Aici este procedura de calcul a Root, greutatea i costul matrice:


COMPUTE (nr,dr_med)
for i=0,2,..,nr do
g(i,i)_qi
for j=i+1,i+2,..,nr do
g(i,j)_g(i,j-1)+qi+pi
for i=0,1,..nr do
c(i,i)_g(i,i)
for i=0,1,..,nr-1 do
j_i+1
c(i,j)_c(i,i)+g(i,j)
r(i,j)_j
for d=2,3,..,nr do
for i=0,1,..,nr-d do
min _ 32000
for k=i+1,i+2,,d+I do
x_ c(i,k-1)+c(k,d+i)
if x<min
then
min_x
m_k
c(i,d+i)_min+g(i,d+i)
r(i,d+i)_m

Aici este procedura pentru construirea arborelui, folosind radacina matrice.

BUILD_OBST(i,j)
if i=j
then p _0
else
p->left_ BUILD_OBST (i,r(i,j)-1)
p->key_key(r(i,j) )
p->right_ BUILD_OBST (r(i,j),j)
return p

Algoritmul necesit O (n2) timp i O (n2) de stocare. Prin urmare, creste 'n' ca acesta va rula
dinde depozitare, chiar nainte de a rmne fr timp. stocare necesar poate fi redus de aproape
jumtate de punere n aplicaretablouri bidimensionale ca reea unidimensional.

2.Exemple de arbori binari de cautare optimali

Gsii arbore binar de cutare optim pentru N = 6, avnd cheile k1 ... k6 i greuti p1 = 10, p2
= 3, p3 = 9,p4 = 2, = 0 P5, P6 = 10; q0 = 5, q1 = 6, q2 = 4, Q3 = 4, Q4 = 3, Q5 = 8, Q6 = 0. Figura
urmtoare arat matrice aa cum ar aprea dup iniializarea i dispoziia lor final.

Index 0 1 2 3 4 5 6
1 2
k 3 7 10 25
5 0
p 10 3 9 2 0 10
q 5 6 4 4 3 8 0
Valorile din greutatea matrice au fost calculate n conformitate cu formulele care s-au declarat
anterior, cum urmeaz:

W (0, 0) = q0 = 5 W (0, 1) = q0 + q1 + p1 = 5 + 6 + 10 = 21
W (1, 1) = q1 = 6 W (0, 2) = W (0, 1) + q2 + p2 = 21 + 4 + 3 = 28
W (2, 2) = q2 = 4 W (0, 3) = W (0, 2) + q3 + p3 = 28 + 4 + 9 = 41
W (3, 3) = q3 = 4 W (0, 4) = W (0, 3) + q4 + p4 = 41 + 3 + 2 = 46
W (4, 4) = q4 = 3 W (0, 5) = W (0, 4) + q5 + p5 = 46 + 8 + 0 = 54
W (5, 5) = q5 = 8 W (0, 6) = W (0, 5) + q6 + p6 = 54 + 0 + 10 = 64
W (6, 6) = q6 = 0 W (1, 2) = W (1, 1) + q2 + p2 = 6 + 4 + 3 = 13

Elementele de cost matricei sunt se


calculeaz dup un model de linii care
sunt paralele cu
diagonalei principale.

C (0, 0) = W (0, 0) = 5
C (1, 1) = W (1, 1) = 6
C (2, 2) = W (2, 2) = 4
C (3, 3) = W (3, 3) = 4
C (4, 4) = W (4, 4) = 3
C (5, 5) = W (5, 5) = 8
C (6, 6) = W (6, 6) = 0
C (0, 1) = W (0, 1) + (C (0, 0) + C (1, 1)) = 21 + 5 + 6 = 32
C (1, 2) = W (0, 1) + (C (1, 1) + C (2, 2)) = 13 + 6 + 4 = 23
C (2, 3) = W (0, 1) + (C (2, 2) + C (3, 3)) = 17 + 4 + 4 = 25
C (3, 4) = W (0, 1) + (C (3, 3) + C (4, 4)) = 9 + 4 + 3 = 16
C (4, 5) = W (0, 1) + (C (4, 4) + C (5, 5)) = 11 + 3 + 8 = 22
C (5, 6) = W (0, 1) + (C (5, 5) + C (6, 6)) = 18 + 8 + 0 = 26

C (0, 2) = W (0, 2) + min (C (0, 0) + C (1, 2), C (0, 1) + C (2, 2)) = 28 + min (28, 36) = 56
C (1, 3) = W (1, 3) + min (C (1, 1) + C (2, 3), C (1, 2) + C (3, 3)) = 26 + min (31, 27) = 53
C (2, 4) = W (2, 4) + min (C (2, 2) + C (3, 4), C (2, 3) + C (4, 4)) = 22 + min (20, 28) = 42
C (3, 5) = W (3, 5) + min (C (3, 3) + C (4, 5), C (3, 4) + C (5, 5)) = 17 + min (26, 24) = 41
C (4, 6) = W (4, 6) + min (C (4, 4) + C (5, 6), C (4, 5) + C (6, 6)) = 21 + min (29, 22) = 43

C(1, 5) = W(1, 5) + min(C(1, 1) + C(2, 5), C(1, 2) + C(3, 5), C(1, 3) + C(4, 5), C(1, 4) + C(5,
5)) =
= 39 + min(81, 64, 75, 78) = 103
Arborele rezultat optim este prezentat n figura de mai jos i are o lungime de 188 de cale
ponderat.Calcul poziiile nod n arborele se face n felul urmtor:
- rdcin de copac optim este R (0, 6) = K3;
- radacina de subarborele stng este R (0, 2) = K1;
- radacina de subarborele drept este R (3, 6) = k6;
- radacina de subarborele drept de k1 este R (1, 2) = k2
- radacina de subarborele stng al k6 este R (3, 5) = K5
- radacina de subarborele stng al k5 este R (3, 4) = K4

3.Codul Sursa

#include<stdio.h>

#include<stdlib.h>

#defineNMAX20

typedefstructOBST
{
intKEY;
structOBST*left,*right;

}OBST;
intC[NMAX][NMAX];//costmatrixintW[NMAX][NMAX];//weight
matrixintR[NMAX][NMAX];//rootmatrixintq[NMAX];
//unsuccesfulsearchesintp[NMAX];//frequenciesint
NUMBER_OF_KEYS;//numberofkeysinthetreeintKEYS[NMAX];
OBST*ROOT;

voidCOMPUTE_W_C_R(){intx,min;inti,j,k,h,m;

//ConstructweightmatrixW
for(i=0;i<=NUMBER_OF_KEYS;i++){W[i][i]=q[i];for(j=i+1;j<=NUMBER_OF_KEYS;j+
+)
W[i][j]=W[i][j1]+p[j]+q[j];}

//ConstructcostmatrixCandrootmatrixRfor(i=0;i<=
NUMBER_OF_KEYS;i++)C[i][i]=W[i][i];for(i=0;i<=
NUMBER_OF_KEYS1;i++){
j=i+1;C[i][j]=C[i][i]+C[j][j]+W[i][j];R[i][j]=j;
}for(h=2;h<=NUMBER_OF_KEYS;h++)for(i=0;i<=
NUMBER_OF_KEYSh;i++){
j=i+h;m=R[i][j1];min=C[i][m1]+C[m][j];for(k=m+1;k<=R[i+1][j];k+
+){
x=C[i][k1]+C[k][j];
if(x<min){m=k;min=x;
}}C[i][j]=W[i][j]+min;R[i][j]=m;
}

//DisplayweightmatrixWprintf("\nTheweightmatrixW:\n");for(i=0;i
<=NUMBER_OF_KEYS;i++){for(j=i;j<=NUMBER_OF_KEYS;j+
+)printf("%d",W[i][j]);printf("\n");}

//DisplayCostmatrixCprintf("\nThecostmatrixC:\n");for(i=0;i<=NUMBER_OF_KEYS;i++){
for(j=i;j<=NUMBER_OF_KEYS;j++)printf("%d",C[i][j]);
printf("\n");}

//DisplayrootmatrixR
printf("\nTherootmatrixR:\n");for(i=0;i<=NUMBER_OF_KEYS;i++){for(j=i;j<=
NUMBER_OF_KEYS;j++)printf("%d",R[i][j]);printf("\n");}}

//Constructtheoptimalbinarysearchtree
OBST*CONSTRUCT_OBST(inti,intj)
{OBST*p;

if(i==j)p=NULL;
else{p=newOBST;p>KEY=KEYS[R[i][j]];p>left=CONSTRUCT_OBST(i,R[i][j]1);//leftsubtreep
>right=CONSTRUCT_OBST(R[i][j],j);//rightsubtree
}returnp;}

//Displaytheoptimalbinarysearchtree
voidDISPLAY(OBST*ROOT,intnivel){inti;if(ROOT!=0){
DISPLAY(ROOT>right,nivel+1);for(i=0;i<=nivel;i++)
printf("");printf("%d\n",ROOT>KEY);DISPLAY(ROOT>left,nivel+1);
}}voidOPTIMAL_BINARY_SEARCH_TREE(){
floataverage_cost_per_weight;

COMPUTE_W_C_R();printf("C[0]=%dW[0]=%d\n",C[0][NUMBER_OF_KEYS],W[0]
[NUMBER_OF_KEYS]);average_cost_per_weight=C[0][NUMBER_OF_KEYS]/(float)W[0]
[NUMBER_OF_KEYS];printf("Thecostperweightratiois:%f\n",average_cost_per_weight);ROOT=
CONSTRUCT_OBST(0,NUMBER_OF_KEYS);
}

intmain(){inti,k;printf("Inputnumberofkeys:");scanf("%d",&NUMBER_OF_KEYS);
for(i=1;i<=NUMBER_OF_KEYS;i++){printf("key[%d]=",i);scanf("%d",&KEYS[i]);printf("
frequency=");scanf("%d",&p[i]);
}for(i=0;i<=
NUMBER_OF_KEYS;i++)
{printf("q[%d]=",i);
scanf("%d",&q[i]);}while(1){
printf("1.Constructtree\n2.Displaytree\n3.Exit\n");scanf("%d",&k);switch(k){
case1:OPTIMAL_BINARY_SEARCH_TREE();break;
case2:DISPLAY(ROOT,0);break;
case3:exit(0);break;}}system("PAUSE");}

S-ar putea să vă placă și