Documente Academic
Documente Profesional
Documente Cultură
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:
-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.
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.
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.
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
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");}