Apostila Árvores

7/26/2019 Apostila rvores

1/56

rvore:

Sees 5.1 e 7.2 do livro "Estruturas de Dados Usando C" de Tenembaum, Lansam e !uensteinSees 5. e 5.5 do livro do Sede#i$%

Dado um conjunto de vrtices e arestas, um caminho uma lista de vrtices distintos na qual cadavrtice na lista conectado ao prximo por uma aresta.

rvore (livre): Um conjunto de vrtices (nodos) e arestas que satisfaz a seguinte condi!o" existe exatamenteum caminho conectando qualquer par de nodos.#e houver algum par de nodos para o qual existe mais de um caminho ou nenhum caminho temos um grafo.

Floresta: Um conjunto de $rvores disjuntas.

%m computa!o"

%m geral, $rvores referem&se a estruturas que possuem um nodo designado como raiz. 'estas$rvores, cada nodo a raiz de uma su$rvore.

Desenho da $rvore"

aiz no topo"

& existe a no!o de um nodo estar acima (mais prximo da raiz) ou aaixo dele (mais longe daraiz)& *+" todo nodo, exceto a raiz tem um -nico pai, que o nodo logo acima dele& /01#" s!o os nodos logo aaixo de um determinado nodo& 2+1 3 +41 3 +#5%#6+/3 D%#5%'D%'6%& 1/0+# ou nodos terminais" nodos que n!o possuem filhos& nodos '6%'1# ou n!o terminais" que possuem filhos

& $rvores 1D%'+D+#" $rvores nas quais a ordem dos filhos significativa& $rvores n&aria" $rvores nas quais todos os nodos internos origatoriamente tem 7n7 filhos.%x" $rvore in$ria.

'estas $rvores em geral utilizado o conceito de 7nodo externo7 (que n!o possui filhos), referenciadopor nodos internos que n!o tem o n-mero especificado de filhos. 'este caso, 1/0+ um nodo interno cujosfilhos s!o todos nodos externos.

'8vel de um n"

'8vel da raiz 9 :'8vel de outros ns 9 n8vel do pai ; ;< nodos externos e a suarv. dir &+%+11 nodos externos.+ssim, a $rvore tem -%1 -&+%+11 ' &1nodos externos.

?rvore in$ria completa de altura d uma $rvore in$ria na qual todos os nodos externos est!o non8vel d.

@) a quantidade de nodos externos em uma arv.in.compl de altura d ' 2/0d

A) quantidade de nodos em uma $rvore in$ria completa de altura d ' 2/0d1 1

*rova por indu!o em d"Base" n 9 : ($rvore vazia) 3nodos ' 2/0(1 + 1 ' 1 -1 nodo e4terno0iptese da indu!o" Uma $rvore in$ria completa de altura d tem 2/0d1 + 1nodos.*asso da indu!o"

Uma arv.in.compl de altura d tem @Cd nodos externos. +ssim, aumentando < a alturada $rvore, cada um destes nodos passa a ser pai de dois outros nos. +ssim, nodosem uma $rvore de altura d;esq ) + contaNodo( p->dir ) + 1;}

+ltura de uma $rvore"

int altura( +pontador p )H int he, hdI

if( p 99 'U// ) return :I he 9 altura( p&=esq )I hd 9 altura( p&=dir )I

if (he = hd )return he;


6/56

6ipo astrato de dados (6+D)"

K um conjunto de operaGes associado a uma estrutura de dados, de tal forma que hajaindependFncia de implementa!o para as operaGes

Dicion$rio ou 6aela de #8molos"

Um dicionario um 6+D que contem itens com chaves e que d$ suporte a seguintes operaGes$sicas" inicializa, insere um novo elemento, remove um elemento e pesquisa o item que contem umadeterminada chave.

& analogia com dicionario da l8ngua portuguesa" chave 9 palavra, registro9 pronuncia, sinLnimo,defini!o, etc.


7/56

rvore Binria de Busca

Se:o 12.5, 12.9, 12.;, 12.< -Sede#i$%

K uma $rvore in$ria na qual para todo no n, os elementos da su$rvore a esquerda contem chavescom valores menores que a chave de n e a su$rvore a direita contem chaves maiores que a chave de n.

mplementa!o"

+ implementa!o aaixo usa um nodo (nodo'ull) para a representa!o de nodos externos ao invs dovalor 'U//"

#include

typedef struct nodo *Apontador;typedef struct nodo { longInt chave; ...

Apontador dir, esq; int contaNodo;} Nodo;

static Apontador raiz, nodoNull;

Apontador criaNodo( longint chave, Apontador esq, Apontador dir, int N ){ Apontador p;p = malloc( sizeof *p );

p->chave = chave; p->esq = esq; p->dir = dir; p->contNodo = N; return p;}

void inicializaDic() { nodoNull = criaNodo( 0, 0, 0, 0 ); raiz = nodoNull; return;}

Apontador buscaArv( Apontador p, longInt chave ){ if (p == nodoNull) return nodoNull; if (chave == p->chave) return p; if (chave < p->chave)

return buscaArv( p->esq, chave ) else return buscaArv( p->dir, chave );}

Apontador insereArv( Apontador p, longint chave){ if( p == nodoNull) return criaNodo( chave, nodoNull, nodoNull, 1 ); if( chave < p->chave)

p->esq = insereArv(p->esq, chave); else p->dir = insereArv(p->dir, chave); (p->contaNodo)++; return p;}

nser!o & un!o terativa"Apontador insereArv( longint chave ){ Apontador p, paiP;


8/56

if( raiz == nodoNull ){ raiz = criaNodo( chave, nodoNull, nodoNull, 1 ); return raiz; } p = raiz; while( p != nodoNull ){

paiP = p; if( chave < p->chave ) p = p->esq; else p = p->dir; } p = criaNodo( chave, nodoNull, nodoNull, 1 ); if( chave < paiP->chave ) paiP->esq = p; else paiP->dir = p; return p;}

1rdena!o por ?rvore"

Composta por 2 passos: n, onde s o comprimento do caminho interno, ou seja, a soma do comprimentos dos caminhosentre a raiz e cada um dos nos da $rvore. sto se deve ao fato de para acessar um determinado no de n8vel l,s!o necess$rias l;< comparaGes.

& pode ser mostrado que o n-mero esperado de comparaGes em uma arv. de pesquisa randLmica


9/56

nser!o na raiz"

%xemplo"20

10 30 25 35

21 27

nser!o da chave @O"

26 20 30 10 25 35 que viola a def. de Arv.Bin.Busca 21 27

"oluo:#rie de rotaGes aps a inser!o do elemento na folha" 20

10 30 25 35 21 27 26

esq; p->esq = q->dir; q->dir = p; return q;}

Apontador rotEsq( Apontador p ){ Apontador q;

q = p->dir; p->dir = q->esq; q->esq = p; return q;}

Apontador insereArv( Apontador p, longint chave ){ if( p == nodoNull ) return criaNodo( chave, nodoNull, nodoNull, 1 );

if( chave < p->chave ){ p->esq = insereArv( p->esq, chave ); p = rotDir( p ); } else { p->dir = insereArv( p->dir, chave ); p = rotEsq( p ); } return p;}

void insereDic( longint chave ){ raiz = insereArv( raiz, chave ); return;}


10/56

rvore Balanceada A#$ (rvore de Adelson% #els&ii e $andis)=tt8?>>###.@outube.$om>#at$=Av'mB#i9>###.@outube.$om>#at$=Av's5#6Gn@;!-inser:o, rota:o, remo:ohttp"33RRR.lcad.icmc.usp.r3Snonato3%D3=tt8?>>###.@outube.$om>#at$=Av'1HGt@t76E!#-e4em8lo de inser:o e rota:o

2otiva!o"

Tarantir custo 1(log n) para usca, inser!o e remo!o

+ordagem"

2anter a $rvore alanceada aps cada opera!o

Descri!o"

Uma $rvore in$ria de usca na qual, para todos os ns, as alturas de suas su$rvores n!o diferemem mais de


11/56

'otao a esquerda do n n:&o alanceamento de n e de todos os seus ancestrais (depois da rota!o) aumenta de 1 f = esquerda(a) se bal(f) == 1 rotaoDireita(a) bal(a) = bal(f) = 0

seno neto = direita(f) rotaoEsquerda(esquerda(a)) rotaoDireita(a)

se bal(n) == 0 bal(a) = bal(f) = 0 seno se bal(neto) > 0 bal(a) = -1; bal(f) = 0; seno bal(a) = 0; bal(f) = 1;

bal(neto) = 0

Apontador Insere(Registro r, Apontador p, int *mudouAltura){ if( p == nodoNull ){ *mudouAltura = TRUE; return criaNo( r, nodoNull, nodoNull ); } if( r.Chave Reg.Chave ){ p->Esq = Insere( r, p->Esq, mudouAltura ); if( *mudouAltura ){ p->bal++; if( p->bal == 0 ) *mudouAltura = FALSE;

else if( p->bal == 2){ *mudouAltura = FALSE; balanceia( &p ); } } } else { p->Dir = Insere( r, p->Dir, mudouAltura ); if( *mudouAltura ){ p->bal--; if( p->bal == 0 ) *mudouAltura = FALSE; else if( p->bal == -2){ *mudouAltura = FALSE;

balanceia( &p ); } } } return p;}

emo!o de nodo"

Ideia:


14/56

& sustituir a chave em nodoW pela chave em nodoem

Cuidados na remoo do novo da rvore:

& caso o nodo ficar desalanceado, alancear da mesma forma que na inser!o & a remo!o de um nodo pode causar diversas operaGes de alanceamento a partir de nodoem ata raiz

& a mesma estrategia utilizada pela inser!o de manter um parXmetro (mudou+ltura) pode ser usadana remo!o" ele verdadeiro caso a su$rvore mudou de altura e falso caso contrario.& a mudana de altura da su$rvore com raiz em 7n7 pode ser verificada testando o alanceamento

original de n" se o alanceamento for zero, uma remo!o n!o vai alterar sua altura, uma vez que a remo!o deum nodo na su$rvore do filho esquerdo n!o altera a altura da su$rvore do filho direito (e vice&versa).*ortanto a altura da su$rvore com raiz em n tamm n!o se altera.

& oserve que uma opera!o de alanceamento em um nodo n tamm altera sua altura.

void Remove(TipoChave k, Apontador *raiz ){ Apontador nodoK, nodoRem; Registro regRem; int mudouH;

/* busca nodo que contem chave k */ nodoK = busca( k, *raiz );if( nodoK == nodoNull )

return;

/* busca nodo com dados que vao substituir chave k que sera' removida */ if( nodoK->Dir == nodoNull && nodoK->Esq == nodoNull ) nodoRem = nodoK; else if(nodoK->bal > 0 ) nodoRem = buscaMaior( nodoK->Esq ); else nodoRem = buscaMenor( nodoK->Dir ); regRem = nodoRem->Reg;

/* remove nodoRem da rvore */ /* nodoRem folha ou tem um nico filho */ *raiz = removeR( nodoRem, *raiz, &mudouH ); nodoK->Reg = regRem; return;}

Apontador removeR( Apontador nodoRem, Apontador p, int *mudouH ){ Apontador filho;

/* remove nodoRem: se for folha retorna nodoNull;

caso constrario retorna o endereo do seu nico filho */ if( p == nodoRem ){ if( p->Dir != nodoNull ) filho = p->Dir; else if( p->Esq != nodoNull ) filho = p->Esq; else filho = nodoNull; free( p ); *mudouH = TRUE; return filho; } else if( nodoRem->Reg.Chave < p->Reg.Chave ){

p->Esq = removeR( nodoRem, p->Esq, mudouH ); if( *mudouH ){ if( p->bal == 0 ) /* se o balanceamento era originalmente = 0*/


15/56

*mudouH = FALSE; /* a remoo no altera a altura da subarv.*/ p->bal--; if( p->bal == -2 ) /* mesmo balanceando a altura da subarv. muda*/ balanceia( &p ); }

} else { p->Dir = removeR( nodoRem, p->Dir, mudouH ); if( *mudouH ){ if( p->bal == 0 )

*mudouH = FALSE;p->bal++;

if( p->bal == 2 ) balanceia( &p ); } } return p;}

+ltura"

+ altura de uma $rvore +4/ com n nodos Y9


16/56

rvores 2--*

#e!o )

=tt8?>>###.@outube.$om>#at$=Av'b=Bi4I+$JKE-nser:o em uma rv. 2+M=tt8?>>###.l$ad.i$m$.us8.br>Nnonato>ED>

Defini!o"Uma $rvore @&A&E uma $rvore que est$ vazia ou que composta por A tipos nodos"

&nodos&@" contem uma chave >< e dois apontadores, p< e p@. 1 apontador p< aponta parauma $rvore com valores de chave menores que >< e o apontador p@ aponta para uma $rvore com valores dechave maiores que >@.

&nodos&A" contem duas chaves >@ e trFs apontadores, p< e Y>@, epA aponta para uma $rvore com valores de chave = >@

&nodos&E" contem trFs chaves >@, >A e quatro apontadores, p@, pA aponta para uma $rvore com valores de chave =>@ e Y>A, e pE aponta para uma $rvore com valoresde chave =>A.

Defini!o"

Uma $rvore @&A&E alanceada uma $rvore @&A&E na qual todos os nodos folha est!o no mesmo n8vel.

*esquisa"

& cada nodo possui no m$ximo A chaves (>Z:[,>ZZ@[) e E apontadores (pZ:[,pZ


17/56

nser!o"

+ inser!o de uma chave > pode ser feita da mesma forma que em uma $rvore in$ria. +pos umausca sem sucesso, inserir a chave na folha.*rolema" a $rvore pode ficar desalanceada

%xemplo" R

/ \ A S inserir C, H, I

+ordagem para alancear"


18/56

se( r.Chave == p->Reg[i].Chave ) /* chave jexiste */ ERRO; seno se( p->Reg[i].Chave > r.Chave ){ Insere( r, p->Ap[i] );

Insere( r, p->Ap[q->NumReg])

se p for folha procura posio pos em p para inserir r desloca registros nas posies [pos, NumReg] insere registro r na posio r q->NumReg++;


19/56

rvore 'u+ro-,era

Ca8. 1 de CormenOLeisersonOPivesthttp"33RRR.]outue.com3Ratch^v9D4p/2eTT&_s('T/`#, defini!o, inser!o, prova da altura)http"33RRR.ic.unicamp.r3Szanoni3moOAP3aulas3arvoresuro'egras.pdf

Defini!o"

%m uma arv. uro&negra"


20/56

& pai da raiz de uma $rvore n!o vazia o nodo'ulo& todos os nodos externos tamm s!o representados pelo mesmo nodo'ulo.

enum tipoCor {RED, BLACK};

typedef struct no{ Apontador esq, dir;

Apontador pai; longInt chave; tipoCor cor;} No;

RN-insere(raiz, k){ novoNodo = criaNodo( k ) x = raiz; paiX = nodoNulo; enquanto x nodoNulo paiX = x; se k < chave(x) x = esq(x)

senao x = dir(x)

pai(novoNodo) = paiX se paiX = nodoNulo raiz = novoNodo senao se k < chave(paiX) esq(paiX) = novoNodo senao

dir(paiX) = novoNodo cor(novoNodo) = RED arrumaArvRN( raiz, novoNodo )}

arrumaArvRN( raiz, p ){ enquanto cor(pai(p)) = RED se pai(p) == esq(pai(pai(p))){ /* insercao na subarv.esq */ tio = dir(pai(pai(p))) se cor(tio)== RED{ /* cor a dir. do avo vermelho */ cor(pai(p)) = BLACK /* Caso 1 */ cor(tio) = BLACK cor(pai(pai(p)) = RED p = pai(pai(p)) } senao{ /* cor a dir. do avo preto */ se p == dir(pai(p)){ /* desbal. na subarv.dir do filho esq*/ p = pai(p) /* Caso 2: esq-dir */

rotEsq(p) } cor(pai(p)) = BLACK /* Caso 3 esq-esq*/ cor(pai(pai(p))) = RED rotDir( pai(pai(p) ) } senao{

/* insercao na subarv. direita -- idem trocando dir esq*/ } cor(raiz) = BLACK}


21/56

5usto e +ltura"

insere+rvBin & Q-lo n Rhile executado no 5aso < no maximo log(n) vezes, portanto, custo total 1(log n)+ltura 2l-n 1

emo!o em +rv. uro&'egra"

$ema:

+ altura de uma arv. ' com n nodos tem altura de no m$ximo @log(n;


22/56

raiz = filho seno se nodoRem == esq(pai(nodoRem)) esq(pai(nodoRem)) = filho seno dir(pai(nodoRem)) = filho se nodoK nodoRem /* copia chave e dados do nodoRem para nodoK */

se cor(nodoRem) == BLACK arrumaRem-RN( raiz, filho )}

arrumaRem-RN( raiz, p ){ enquanto p raiz e cor(p) == BLACK se n == esquerda(pai(p)){ /* extra BLACK a esquerda */ d = direita(pai(p))

se cor(d) == RED{ /* Caso 1 */ cor(d) = BLACK cor(pai(p)) = RED rotaoEsq( pai(p) )

d = direita(pai(p)) } se cor(esquerda(d)) == BLACK e cor(direita(d)) == BLACK{ cor(d) = RED /* Caso 2 */ p = pai(p) } seno{

se esquerda(d)->cor == RED /* direita(d)->cor == RED */ cor(d) = RED /* Caso 3 */ cor(esquerda(d)) = BLACK rotaoDir( d ) d = direita( pai(p) ) }

cor(d) = cor(pai(p)) /* Caso 4 */ pai(p)->cor = BLACK cor(direita(d)) = BLACK rotaoEsq ( pai(p) ) p = raiz; }

seno{ /* extra BLACK a direita -- similar */ } cor(p) = BLACK}

Caso .:#e o irm!o de p for vermelho, seus dois filhos s!o pretos. 1 ojetivo do 5aso < transformar o irm!o de p em

preto (5asos @, A ou E). *ara isso, troca&se a cor do irm!o para preto, o pai para vermelho e faz uma rota!o.5omo os filhos do irm!o s!o pretos, o novo irm!o de p ser$ preto.'a $rvore @&A&E, este caso equivale ao pai de p ser um nodo do tipo&A. 1 5aso < corresponde a transformaruma representa!o deste tipo de nodo, com a chave de maior valor como raiz da su$rvore na representa!odeste tipo de nodo na B em outra representa!o com a chave de menor valor como raiz da su$rvoreI evice&versa.

Caso 2:#e o irm!o direito preto e seus dois filhos s!o pretos troca a cor do irm!o par vermelho, isso j$ compensa opreto extra da suarv. esquerda.'a arv. @&A&E este caso corresponde ao 7merge7 de nodos do tipo&@I ou seja, seu irm!o um nodo do tipo&@ en!o tem chaves para emprestar.

Caso *:#e o irm!o direito d preto. #e o filho direito de d vermelho transforma ele em preto para compensar o pretoextra. 6roca cores. az rota!o a esquerda em pai(n)


23/56

'a arv. @&A&E este caso corresponde ao emprstimo de uma chave do irm!o.

Caso :#e o irm!o direito d preto. #e o filho esquerdo de d vermelho, faz uma rota!o para transformar este casono 5aso E" 6roca as cores de R e esquerdo(R) ota!o a direita de R

R 9 direita(pai(n))

'a arv. @&A&E este caso corresponde ao emprstimo de uma chave do irm!o.porm, o irm!o na B n!o est$ na representa!o dir&dir ou esq&esq. *ortanto, necess$rio fazer uma rota!opara transforma&la no 5aso E.


24/56

rvores B

Ca8. 9 -&ivio + Ca8. 1; -Cormen=tt8?>>###.@outube.$om>#at$=Av'RFH!94Rl-deFini:ohttp://www.youtube.com/watch?v=ANZBJw3a944-inser:o, remo:o -!ten:o? a deFini:o de rauV diFerente da Rue a8resentada 8ela Carmem=tt8?>>###.l$ad.i$m$.us8.br>Nnonato>ED>6arvore>btree.=tm-seue a deFini:o de rau da Carmem

2otiva!o"

& ndexa!o em memoria secundaria& Teneraliza!o de uma $rvore @&A&E

Defini!o"

K uma $rvore n&aria. %m uma $rvore B com grau minimo m temos que"


25/56

retorna Busca(p_i[x], k)

,mero de acessos a disco: no pior caso lo6t-n

3empo de C4: Q-t lo6t-n

nser!o"

& a ideia a mesma da arv. @&A&E" a medida que desce na $rvore, nodos cheios s!o divididos para queseja sempre poss8vel inserir novas chaves em seus filhos (com a possiilidade de uma chave 7suir7)


26/56

Inicializa( T ) x = alocaNodo() folha[x] = TRUE

num[x] = 0 escreve_disco( x ) raiz[T] = x

Acessos a disco e tempo C4: 1(


27/56

p_j[z] = p_{j+t}[f] num[f] = t-1 para j = num[pai]+1 downto ind+1 p_{j+1}[pai] = p_{j}[pai] p_{ind+1}[pai] = z para j = num[pai] downto ind chave_{j+1}[pai] = chave_j[pai]

chave_ind[pai] = chave_t[f] num[pai] = num[pai]+1 escreve_disco(f) escreve_disco(p) escreve_disco(z)

Acessos a 5isco: 1(=1 e k < chave_i[x]

chave_{i+1}[x] = chave_i[x] i = i - 1 chave_{i+1}[x] = k num[x] = num[x] + 1 escreve_disco(x) seno enquanto i >= 1 e k < chave_i[x] i = i - 1 i = i+1 z = le_disco( p_i[x] ) se num[z] = 2t-1 divideNodo( x, i, z ) se k > chave_i[x] i = i + 1 inserenoCheio( p_i[x], k )

Acessos a Disco:O(log_t(n))Tempo de CPU:O(t log_t(n))

emo!o em ?rvores B"

& prolema que pode acontecer" um nodo pode ficar com menos que t&< chaves& solu!o" a medida que faz a usca pelo nodo que contem a chave, garantir que todos os nodos no

caminho tenham pelo menos t chaves (< a mais que o minimo). sso garantido da seguinte forma" se o nodoa ser visitado tem t&< chaves


28/56

buscaEmNodo( x, k ) i = 1 enquanto( i k*/ esq = p[indK](x) se indK


29/56

remove( raiz, x, predK ); chave[indK](x) = predK;

seno se dir NULL and (num(dir) >= t/* filho dir. tem pelo menos t

chaves*/ succK = sucessor( x, k )

remove( raiz, x, succK ); chave[indK](x) = succK

seno /* dois filhos tem t-1 chaves*/ p = merge( x, indK ) se x == raiz free( raiz ) raiz = p remove( raiz, p, k )

seno /* k no estem x */se folha(x)

retorna ERRO seno /* continua descendo na arv. */ se num(esq) >= t remove( raiz, esq, k ) seno

se dir NULL and num(dir) >= t /* empresta chave do irmao direito*/ ... remove( raiz, esq, k ) seno se indK > 1 e num(p[indK-1](x)) >= t

/* empresta do irmao esq */ ...

remove( raiz, esq, k ) seno se dir == NULL p = merge(x, indK-1) seno

p = merge(x, indK) se x == raiz free( raiz ) raiz = p remove( raiz, p, k )

merge( Apontador x, ndice indK ) esq = p[indK](x)

dir = p[indK+1](x) num(esq) = num(esq) + 1 /* junta (esq + k + dir) em esq */ chave[num(esq)](esq) = chave[indK](x); para i = 1 atnum(dir) chave[num(esq)+i](esq) = chave[i](dir) p[num(esq)+i](esq) = p[i](dir) num(esq) = num(esq) + num(dir) p[num(esq)+1](esq) = p[num(dir)+1](dir) free( dir );

para i = indK atnum(x)-1 /* arruma chaves e apont. em x */ chave[i](x) = chave[i+1](x) para i = indK+1 atnum(x) p[i](x) = p[i+1](x) num(x) = num(x) - 1 retorna esq;


30/56

2emria #ecund$ria"

& conceito de prato, trilha, cilindro, caeote de leitura e grava!o & acesso muito mais lento em mem. secundaria que na mem. primaria devido aos componentemecXnicos (rota!o do disco e caeote) & rota!o" ;& P@:: *2 &&= .AA milissegundos para uma rota!o

& acesso a memoria em sil8cio" ;&


31/56

rvore B6

5ap. O, O.A ('ivio)

deia"#eparar nodos de 8ndice de nodos de dados & nodos internos contem apenas 8ndices & todos os registros nas folhas (sem a necessidade de apontadores) & os nodos folha s!o encadeados (para facilitar a usca ordenada de valores) & pode ter um grau distinto para nodos 8ndice e folha

1jetivo"

& acesso sequencial mais eficiente & facilitar o acesso concorrente as dados

%xemplos"&inser!o

&remo!o &usca

+cesso 5oncorrente"

& podem ocorrer prolemas se um processo estiver lendo a estrutura e outro inserindo uma nova chaveque causa divis!o de um nodo

& uma pagina segura se n!o houver possiilidade de mudana na estrutura da $rvore devido ainser!o ou remo!o na pagina inser!o" pagina segura se chaves Y @t&< remo!o" pagina segura de chave = t&& " loqueio para leitura

loc>&" loqueio exclusivo para escrita

$eitura: &(raiz)

@. read(raiz) e torne&a pagina corrente A. enquanto pag. corrente n!o for folha loc>&(descendente) unloc>(pag corrente)

read(descendente) e torne&a pagina corrente

Atuali1ao: &(raiz) @. read(raiz) e torne&a pagina corrente A. enquanto pag. corrente n!o for folha loc>&(descendente) read(descedente) e torne&a paginal corrente #e pag. corrente for segura unloc>(p) para todos os nodos p antecedentes que tenham sido loqueados


32/56

7!todo de Acesso "equencial Inde0ado (I"A7)

& parecido com o $rvore B;, mas utiliza paginas de overfloR& h$ uma previs!o inicial da quantidade de registros do arquivo, deixando cerca de @:N das paginas

inicialmente livres

& vantagem" n!o haV necessidade de loqueio nas paginas de 8ndice& desvantagem" pode haver um 7desequil8rio7 da quantidade de registros em cada intervalo


33/56

8eap

=tt8?>>###.@outube.$om>#at$=Av'dPLML@i$-deFini:o, Kea8sort, vo do Goole=tt8?>>###.@outube.$om>#at$=Av'6>###.@outube.$om>#at$=Av'DK=H(1rGs-&GLXS, adi:o, remo:o, 8arte 2=tt8?>>###.@outube.$om>#at$=Av';4ZU2TJ%s[#-&GLXS, 8ro8riedades, $onstru:o, Kea8F@

K a representa!o bem forma de vetorb de uma $rvore in$ria em ordem&heap.& /emrando" uma $rvore in$ria quase completa de altura d

+rv. in$ria na qual" A[i] troca(A[i], A[maior]) arrumaHeap( maior ) }

}

Custo: Q-lo-n
http://www.youtube.com/watch?v=QdRL3XLyiVchttp://www.youtube.com/watch?v=_9QXNFcrF4chttp://www.youtube.com/watch?v=DHhPg01rBGshttp://www.youtube.com/watch?v=DHhPg01rBGshttp://www.youtube.com/watch?v=8xJU2TZksWwhttp://www.youtube.com/watch?v=QdRL3XLyiVchttp://www.youtube.com/watch?v=_9QXNFcrF4chttp://www.youtube.com/watch?v=DHhPg01rBGshttp://www.youtube.com/watch?v=8xJU2TZksWw


34/56

arrumaHeapUp (A, i):{

enquanto i > 1 e A[i/2] < A[i]troca(A[i], A[i/2])

i = i/2 } }

constriMaxHeap( A ):{ tamHeap( A ) = tam(A);

para i = tamHeap(A) / 2 ate 1 em ordem decrescente arrumaHeapDown( A, i ); }

9+servao: todos os elemento com 8ndice maior que floor( tam0eap( +)) s!o folhas. *ortanto a itera!o sprecisa tratar os elementos armazenados nos 8ndices menores que este (nodos internos).

Custo: n>2 lo-n ' Q-n lo-n

0eapsort"

heapSort (A) { constriMaxHeap( A ); para i = tam( A ) at2 { troca( A[1], A[i]; tamHeap( A ) = tamHeap( A ) - 1; arrumaHeapDown( A , 1 ) } }

Custo: $onstr\iKea8? Q-n lo-n n arrumaKea8 ? n Q-lo -n3otal: Q-n lo-n

%mora o custo do heapsort seja o mesmo do quic>sort, na pratica o quic>sort em geral mais rapido. 2asuma das aplicaGes para o 0eap a implementa!o de uma lista de prioridades.

/ista de *ropriedades "-8ode ser lista+ma4 ou lista+min, aRui V $onsiderado lista+ma4

K uma estrutura para manter um conjunto de elementos #, cada um com um valor associado, chamado dechave. Deve prover as seguintes funGes"

& insere( #, x )" insere o elemento x em # & m$ximo( # )" retorna o maior elemento em #

& extrai2ax( # )" remove e retorna o maior elemento de #

%xemplo de aplica!o"& %scalonamento de processos"

0uffman (lista&min)

mplementa!o"-re8resentando o $on]unto S em um Kea8 !

mximo( A ){ retorna A[1] }

Custo: Q-1

extraiMax( A ){


35/56

se tamHeap( A ) < 1 retorna erro; max = A[1] troca( A[1], A[tamHeap(A)] tamHeap(A) = tamHeap(A) - 1 arrumaHeapDown( A, 1 ); retorna max }

Custo: arrumaKea8 ' Q-lo-n

insere( A, k ){ tamHeap(A) = tamHeap(A) + 1; A[i] = k;

arrumaHeapUp( A, tamHeap(A));

Custo:Q- lo-n


36/56

rvores de esquisa 5iitais

Ca8. 15 -Sede#i$%

*ara aplicaGes nas quais a usca feita em apenas uma parte da chave. 1u seja, quando a chave pode serdecomposta em pedaGes de tamanho fixo (]tes ou its).K necess$rio haver uma opera!o eficiente para oter a i&sima parte da chave

#antaens: & custo do pior caso razo$vel, sem necessidade de alanceamento & permite chaves de tamanho vari$vel

rvore de esquisa 5iital Binria:

+ arv. digital tem custo quase timo para aplicaGes com grande volume de chaves, com f$cilimplementa!o (; f$cil que avl, ruro&negra). 1 desempenho muito om desde que exista uma opera!oeficiente de acesso aos its que compGe a chave.

& as chaves s!o representadas por sequFncia de its

& cada n pode ter dois filhos& os its s!o analisados do mais significativo para o menos significativo. #e for igual a zero, a chave

armazenada no filho esquerdo, caso contrario, no filho direito& a $rvore n!o mantem as chaves em ordem. + ordem somente garantida para chaves no mesmo

n8vel.& a caracter8stica da $rvore que uma chave est$ armazenada em algum nodo no caminho

determinado pela sua sequencia de its& considerando chaves de tamanho fixo com R its (e sem repeti!o de chaves), a quantidade de

chaves ' a ser inserida na $rvore Y9 @CR.& a $rvore digital apropriada se a quantidade de chaves for significativamente menor que @CR. 5aso

contrario, uma $rvore de pesquisa +4/ ou ruro&negra seria mais apropriada.&para chaves de A@ its, a arv. digital seria apropriada se o n-mero de chaves for no m$ximo


37/56

mplementa!o"

strutura de 5ados: (dFntica a $rvore in$ria)

typedef long TipoChave; typedef struct Registro { TipoChave Chave; /* outros componentes */ } Registro; typedef struct No *Apontador; typedef struct No { Registro Reg; Apontador Esq, Dir; } No;

busca: busca(raiz, chave, 0) /* nodo, valor, ordem do bit */

busca( p, k, w ) kNodo = p->reg.Chave; se( p == NULL) retorna NULL; se( kNodo == k ) retorna p->reg; se( digito(k, w) == 0 ) retorna busca( esquerda(p), chave, w+1 ) seno retorna busca( direita(p), chave, w+1 )


38/56

3rie

#imilar as arv. de usca digitais, mas mantem as chaves em ordem e armazena chaves somente nasfolhas.

Defini!o"

Uma trie uma $rvore in$ria que possui chaves associadas aos nodos folhas e definidarecursivamente da seguinte forma"

a) a trie para um conjunto vazio de chaves apenas um apontador 'U//I ) a trie para apenas uma chave composta apenas por um nodo folha que contem esta chave c) a trie para um conjunto de chaves maior que um composta por um nodo interno, sendo o filho

esquerdo uma trie contendo chaves cujo it inicial : e o filho direito uma trie contendo chaves cujo it inicial esq == nodoNulo e p->dir == nodoNulo se p->reg.Chave == k

retorna p->reg seno retorna nodoNulo; se digito(k, w) == 0 retorna busca( p->esq), chave, w+1) seno retorna busca( p->dir, chave, w+1)

inicializa() return criaNodo( chaveNula )


39/56

chamada: insert(raiz, chave, 0)

insert(p, k, w) kNodo = p->reg.Chave; se p == nodoNulo retorna criaNodo( k ); se p folha ento retorna split( criaNodo(k), p, w );

se digito(k, w) == 0 p->esq = insert( p->esq, chave, w+1 ) seno p->dir = insert( p->dir, chave, w+1 ) retorna p;

split( p1, p2, w) n = criaNodo( itemNulo ); d1 = digito(p1, w); d2 = digito(p2, w); se d1 == d2

se d1 == 0n->esq = split( p1, p2, w+1 )

seno n->dir = split( p1, p2, w+1 ) seno se d1 == 0 n->esq = p1; n->dir = p2; seno n->esq = p2; n->dir = p1; retorna n;


40/56

rvore atricia (ractical Alorit;m to 'etrieve In o primeiro it no qual a chave difere da chave do seu pai. #eja >p o 8ndice it do pai. #e o it >pda chave igual a : ent!o ' o filho esquerdo do paiI caso contrario, ele o filho direito.

Um nodo externo pode corresponder a 'U// ou ao endereo de um nodo +, que igual a ' ou um ancestral

de '. #ejam n


41/56

G 00111X 11000M 01101P 10000L 01100

mplementa!o"

strutura de dados:

typedef long TipoChave; typedef struct Registro { TipoChave chave; /* outros componentes */ } Registro; typedef struct No *Apontador; typedef struct No { Registro reg; Int bit; Apontador esq, dir;

} No;

1s" para simplificar a implementa!o, a raiz da $rvore sempre um nodo com 7chave nula7 (todos os itsiguais a :, um valor n!o utilizado como valor de chave) e campo it igual &esq, k, -1 ) pk = p->chave se k == pk retorna; /* chave jestna rvore */ i = 0; /* procura bit que diferencia k da chave dep */ enquanto digito(k, i)==digito(pk, i)


42/56

i++; raiz->esq = insereR (raiz->esq, reg, i, raiz)

insereR( p, reg, bit, paiP ) se p->bit >= bit ou p->bit bit n = criaNodo( reg, bit ) se digito(reg.chave, bit) == 0

n->esq = n; n->dir = p; seno n->esq = p; n->dir = n; retorna n se digito(reg.chave, bit) == 0 p->esq = insereR( p->esq, reg, p->bit, p ) seno p->dir = insereR( p->dir, reg, p->bit, p ) retorna p

1s" a inser!o de um nodo com it menor do que um j$ existente corresponde a inser!o na trie no lugar deum filho 7nulo7 de um nodo interno que n!o foi criado na arv. *atricia. #e o it for igual ao de um nodo existente,esta inser!o corresponde na inser!o na trie com 7split7 de uma folha.

5aracter8stica"

6odos os nodos externos aaixo de um determinado nodo n com it de 8ndice > tem como prefixo os mesmos >its.

+ssim, para oter as chaves ordenadas, asta imprimir as chaves dos nodos externos, percorrendo a $rvoreem&ordem.

5hamada" ordenado( raiz&=esq, &< )

ordenado( p, bit )

se p == nodoNulo retorna; se p->bit reg.chave; retorna; ordenado( p->esq, p->bit ) ordenado( p->dir, p->bit )

Custo:nser!o" n-mero mdio de comparaGes 9 log(n) n-mero m$ximo de comparaGes 9 @blog(n) Y9 size1f(>)

+rv. *atricia s!o especialmente indicadas para chaves grandes, pois evitam a compara!o de todos os itsque a compGe.


43/56

3ries n-arias

Se:o 15. -Sed#i$%

Teneraliza!o de tries, na qual chaves s!o codificadas em uma ase qualquer, n!o necessariamente in$ria.

Uma trie n&aria possui chaves armazenadas nas folhas. %la def. rec. Da seguinte forma" uma trie para umconjunto vazio de chaves corresponde ao apontador nuloI uma trie com uma -nica chave corresponde a umafolha contendo esta chaveI uma trie com cardinalidade maior que um um nodo interno com apontadoresreferentes a trie com chaves comeando com cada um dos d8gitos poss8veis, com este digito desconsideradona constru!o das su$rvores.

& %x


44/56

3rie 0istencial:

'!o guarda informa!o sore o registro, apenas se uma determinada chave esta presente ou n!o na trie(n&aria).Uma trie existencial para um conjunto de chaves def. rec. Da seguinte forma" uma trie para um conjunto vazio

de chaves corresponde ao apontador nuloI uma trie para um conjunto n!o vazio de chaves corresponde a umnodo interno com apontadores para nodos filhos contendo valores para cada valor de digito poss8vel. 'estassu$rvores o primeiro digito removido para sua constru!o, de forma recursiva.

%x" casa, ela, rua nser!o" cara, n-mero

& assumimos que nenhuma chave prefixo de outra. sso pode ser garantido de duas formas distintas"

prox = null; return x; }

Item buscaR( Apontador p, Chave v, int w ){ int i = digito(v, w); if (p == null) return NULLItem; if (i == NULLdigit) return v; return buscaR( p->prox[i], v, w+1); }

busca( Chave v ){ return buscaR( raiz, v, 0 ); }

Apontador insereR( Apontador p, Item item, int w ){ Chave v = chave(item); int i = digito(v, w); if (p == null) h = criaNodo(); if (i == NULLdigit) return p; p->prox[i] = insereR( p->prox[i], v, w+1); return p; }

void insere(item){ raiz = insereR( raiz, item, 0); }

5aracter8sticas"

& $rvore com altura aixa& grande n-mero de apontadores nulos


45/56

5onsequFncias"

& aixo tempo de usca 3 inser!o& grande desperd8cio de espao

%xemplo"

Kramos jovens e, como tal, sempre a uscar acelerar o tempo, indagando&nos sore temas que os anoscertamente se encarregariam de responder & mal sa8amos que, para entender certas coisas, astavaenvelhecer.

'a forma de trie existencial, trie existencial astrata e trie existencial ternaria


46/56

6rie 6ernaria

& similar as arv. de usca in$rias, mas que utiliza car$cteres (d8gitos) como chave do nodo& cada nodo tem A apontadores" para chaves que comeam com o digito menor que o corrente, iguais e

maiores

5aracter8stica"

& tempo de usca" tamanho da chave& n-mero de lin>s" no m$ximo A vezes o tamanho total do conjunto de chaves

mplementa!o"

typedef struct nodo *Apontador;struct nodo {int d;

Apontador dir, meio, esq;};Apontador raiz;

void init() {raiz = NULL};

Apontador criaNodo( int d ){ Apontador x = malloc( sizeof *x); x->d = d; x->dir = x->meio = x->esq = NULL; return x;}

TipoChave buscaR( Apontador p, TipoChave k, int w ){ int i = digito(k, w); se (p == NULL) return chaveNULA; se (p == digitoNULO) return k; se (i < h->d) return buscaR( p->esq, k, w ); seno se (i == h->d) return buscaR( p->meio, k, w+1 ); seno buscaR( p->dir, k, w );}

TipoChave busca( TipoChave k ){ return buscaR( raiz, k, 0 );}

4antagens"

& adapta&se as irregularidades (desalanceamento dos car$cteres que aparecem) nas chaves depesquisa& n!o dependem da quantidade de d8gitos (car$cteres) poss8veis& quando a chave n!o est$ armazenada na $rvore, a quantidade de d8gitos comparados tende a ser

pequena (mesmo quando a chave de usca longa)& ela flex8vel"

. pode ser usada para oter chaves que casam com d8gitos espec8ficos da chave de pesquisa . pode ser usada para oter chaves que diferem em no m$ximo uma posi!o da chave depesquisa

& arv. *atricia oferece vantagens similares, mas comparando its ao invs de ]tes.

%xemplo"Busca de todas as palavras que casam com 7cab7, onde 7b7 pode ser qualquer car$cter

char s[MAXTAM];void casaR( Apontador p, char *k, int i ){


47/56

se p == NULL return; se ((*k == '\0') && (p->d == '\0')) { s[i] = p->d; escreve s; } se ((*k == '*') || (*k == p->d)) { s[i] = p->d; casaR( p->meio, v+1, i+1 ); } se ((*k == '*') || (*k < p->d)) casaR( p->esq, k, i );

se ((*k == '*') || (*k > p->d)) casaR( p->dir, k, i );}

void casa( char *k ){ casaR( raiz, k, 0 ); }

2elhoramentos poss8veis na $rvore"


48/56

Compresso de 5ados

#e!o


49/56

n = |C| /* tamanho do conjunto C * Q = C /* Q uma fila de prioridades */ para i= 1 a n-1 z = criaNodo(); p1 = extraiMinimo( Q ) p2 = extraiMinimo( Q )

esq(z) = p1; dir(z) = p2; z->f = p1->f + p2->f insere(Q, z) retorna extraiMinimo( Q )

Codik] = "conteudo da lista" } seno { insereFim( lista, 0 ); geraVetorCod( esq(p), v, lista ); removeFim( lista );

insereFim( lista, 1 ); geraVetorCod( dir(p), v, lista ); removeFim( lista ); }

5ecodik }

%xemplo"*rocesso de constru!o para a palavra +B+5+D+B+.

1 tempo de execu!o da constru!o da codifica!o de 0uffman depende do tempo para oter os car$cteres

em ordem ascendente de frequFncia e inserir novos elementos no conjunto. Utilizando uma lista ordenadaeste tempo Q-n, e a fun!o 0uffman teria gastaria ent!o n&< b n tempo, ou seja, Q-n/2.

Uma alternativa seria a utiliza!o de uma $rvore in$ria alanceada (como +4/ ou '). porm, no prolema


50/56

em quest!o tamm h$ uma limita!o no valor de n, que previamente conhecido. 1u seja, h$ umaquantidade previamente saida de car$cteres que um arquivo pode conter. +ssim, introduzimos mais umaestrutura de dados, chamada de heap para a implementa!o da lista de prioridades.

Uma $rvore est$ bem ordem&maxheapb se a chave em cada nodo maior ou igual s chaves armazenadas emtodos os seus filhos.


51/56

8as;

5ap.


52/56

4sando o cdio A"CII e a posio do carcter:

B ' sum60i'(/0n+1 C=ave^i_ 12;/0n+i+1

%xemplo" pt 9 (bs, que um valorde @R its (r) corresponde aos p its mais significativos de r:.

%xemplo" + 9 :.O


53/56

%xemplo"%ndereamento de A d8gitos5have 9 9 ) 9 ((a>;) mod p) mod m, onde p primo, a em Z:,p) e Z


54/56

+ fun!o =? U 4 0(,..., m+1 ++) 0(,...,m+1

+ssim, para achar a posi!o de armazenamento de uma chave realizada uma usca nas posiGes h(>,:),h(>,,@) at achar uma que esteja vazia.

hash_insert(T, k) /* T a tabela hash */ i = 0

repita j = h(k,i) se T[j] == nil ento T[j] = k; retorna i = i+1 atque i = m retorna "erro: tabela cheia"

Busca similaremo!o" n!o pode colocar nil na posi!o, mas sim um outro valor 7%214D17 para que a posi!o possaser usada novamente por uma inser!o ou a usca continuar o processo at encontrar a chave procurada.

8as;in $inear:

h(>,i) 9 (hV(>) ; i) mod m

%xemplo"chaves 9 mod


55/56

9rdenao 0terna

#e!o E,@ ('ivio)

'ecess$ria quando a quantidade a ser ordenada n!o cae na memoria principal

5onsideraGes"

& o custo para acessar um item algumas ordens de grandeza maior que o os custos deprocessamento na memoria interna. +ssim, o custo de um algoritmo de ordena!o externa considera apenas aquantidade de leituras e escritas em memoria secundaria, ignorando o custo de processamento em memoriaprincipal. & podem existir restriGes quanto ao acesso aos dados (sequencial 3 randLmico)

& o desenvolvimento de algoritmos muito dependente do estado atual da tecnologia

%strategia *rincipal para 1rdena!o"


56/56

99= segundo Wnuth, para n-meros randLmicos, o tamanho da sequencia gerada em mediaigual a @2.

%xemplo com heap size 9 Aent 1 2 3 ordenadoe i n t ir n e* t n

c t e* c* ta a* e* c* a*l c* e* l* c*a e* a l* e*c l* a c l*a a a c ao a c c ab b o c ba c o a* cl l o a* la o a* a* on a* n* a* a*c a* n* c* a*

e c* n* e* c*a e* n* a e*d n* d a n*a a d a a a d a d d

1 heap pode tamm ser utilizado para fazer as intercalaGes, mas s vantajoso quando a quantidade delocos gerados na primeira fase for grande (p. ex. =9 ). 'este caso, necess$rio log@() comparaGes paraoter o menor elemento.

%xemplo"entradas" int cer aal

ent 1 2 3 sai a c i aa a c i al c l i ce e l i er i l r in l n r l n r nt r t r t t

Apostila Árvores

Documents

Transcript of Apostila Árvores