rvores Binrias

grau dos ns
012

INF01203 Estruturas de Dados

ordenadas
rvores Binrias sub-rvore da esquerda sub-rvore da direita

= =
rvore qualquer rvore Binria

Tipos de rvores Binrias Tipos de rvores Binrias

Estritamente Binria Binria Zigue-

Zigue-zague
Binria Completa Cheia Ns interiores possuem exatamente
0 ou 2 filhos Sub-rvores vazias Sub-rvores vazias uma sub-rvore vazia
no ltimo ou somente no ltimo nvel
penltimo nvel
Tipos de rvores Binrias rvore Binria

Dados os tipos de rvores: Comprimento de caminho de uma rvore

estritamente binria tempo de execuo
completa
cheia
zigue-zague *

Qual rvore possui altura mxima ? * * * *

zigue-zague
* * *
Qual rvore possui altura mnima ?
cheia * *

Exemplos de rvores Binrias Implementao

+
Endereo da raiz
A
* /
200
B C A
a b c +
150 350

d e D E F G B C
100 170 250 500

400 600 D E F G
rvores Binrias - vantagens Transformao: n-ria em binria
Irmo seguinte
Otimizao de alocao de memria
Mais fceis de manipular
?
Primeiro filho
Implementao de operaes muito
simplificada A A

B C D B C D
Transformar rvore n-ria em binria
E F G E F G

Transformao: n-ria em binria Transformao: n-ria em binria

A A A
1. O primeiro filho de um nodo passa a ser seu
filho esquerda na rvore binria
B C D B C D B
2. Os demais filhos de um nodo passam a ser
filhos direita do seu irmo imediato esquerda
E F G E F G E C
3. Executar o mesmo processo para cada nodo da
rvore a A D

F
Filho esquerda = primeiro filho B C D
Filho direita = irmo seguinte
G
E F G
Reconstituio rvore n-ria Exerccios

A A
rvore modificada
B A
B C D E
E C B C D Converter Binria
F G H inserir Y filho direita de A
rvore original J D
E J F G L inserir X filho esquerda Y
A inserir Z filho direita Y
F
K L I J K
B C D K G

E F G L

Transformao de Floresta em Binria Transformao de Floresta em Binria

A
Para converter uma floresta em rvore binria,
basta considerar as razes das rvores como ns
B G
irmos e aplicar a converso anterior

C H
A G

D I K
B C D F H K L

E F J L
E I J M

M
 TAD : Estrutura de Dados
raiz raiz
A A

B C
Implementao de rvores Binrias B C

D E
D E

Tipo
Pnodo = Nodo;
Nodo Nodo = registro
esq info dir esq : Pnodo;
info: Dados;
dir : Pnodo
fim;

TAD : Operaes Inicializa

raiz
raiz
Inicializa A
A

Insere Endereo
B C
da raiz B C
raiz
D E
meio A D E
folha
Consulta
B C Criar uma rvore vazia
Remove
Destri proc inicializa(var a: Pnodo);
D E F G incio
a := nil
fim inicializa;
 Insere raiz Insere: filho esqueda
raiz
raiz
A
A proc insereEsq(var a: Pnodo; infoPai, infoFilho: Dados);
B C var pai, novo: Pnodo;
B C incio
D E pai := localiza(a, infoPai);
D E se pai nil
ento
Alocar nodo raiz se pai.esq nil
ento erro(Nodo j possui sub-rvore esquerda)
proc insereRaiz(var a: Pnodo; info: Dados); seno incio {insere o novo nodo}
var raiz: Pnodo; aloca(novo);
incio novo.dir := novo.esq := nil;
alocar(raiz); novo.info := infoFilho;
raiz.esq := raiz.dir := nil; pai.esq := novo;
raiz.info := info; fim;
a := raiz; fim insereEsq;
fim insereRaiz;

Insere: filho direita TAD: Operaes sobre rvores Binrias

proc insereDir(var a: Pnodo; infoPai, infoFilho: Dados); Pnodo = Nodo;

var pai, novo: Pnodo; Nodo = registro
incio esq : Pnodo;
pai := localiza(a, infoPai); info: Dados;
se pai nil dir : Pnodo
ento fim;
se pai.dir nil
ento erro(Nodo j possui sub-rvore direita) proc inicializa(var a: Pnodo);
seno incio {insere o novo nodo} // cria uma rvore vazia
aloca(novo); proc insereRaiz(var a: Pnodo; info: Dados);
novo.dir := novo.esq := nil; // aloca nodo raiz e insere dado
novo.info := infoFilho; proc insereEsq(var a: Pnodo; InfoPai, InfoFilho: Dados);
pai.dir := novo; // insere um nodo na sub-rvore esquerda
fim; proc insereDir(var a: Pnodo; InfoPai, InfoFilho: Dados);
fim insereDir; // insere um nodo na sub-rvore direita
 Consulta Nodos

acesso sempre atravs da raiz

cada nodo deve ser visitado uma vez, e apenas
uma vez
Caminhamentos em rvores Binrias raiz A

B C D
Visita a um nodo E F G
acesso a um nodo
para realizar alguma operao

Caminhamentos Caminhamentos

mtodo de percurso sistemtico de todos os um caminhamento define uma seqncia de

nodos de uma rvore, de modo a que cada nodo nodos
seja visitado exatamente uma vez cada nodo passa a ter um nodo seguinte, ou um
nodo anterior, ou ambos (exceto rvore com 1 s
nodo)
A seqncia de nodos depende do caminhamento
realizar as A
operaes B C D Ex: Caminhamento 1:
A-B-C-D-E-F-G B C D
Caminhamento 2:
A-B-E-C-D-F-G
E F G E F G
 Principais Caminhamentos Caminhamentos
Pr-Fixado esquerda
.Visita a raiz
.Percorre a sub-rvore esquerda
raiz
a .Percorre a sub-rvore direita

a-b-d-e-c-f-g a
Sub-rvore Central esquerda
Sub-rvore .Percorre a sub-rvore esquerda
esquerda b c direita .Visita a raiz
.Percorre a sub-rvore direita b c
d-b-e-a-f-c-g
d e f g Ps-Fixado esquerda
.Percorre a sub-rvore esquerda
d e f g
.Percorre a sub-rvore direita
.Visita a raiz
d-e-b-f-g-c-a

Caminhamentos Exemplo 02
Pr-Fixado direita 130
.Visita a raiz
.Percorre a sub-rvore direita
.Percorre a sub-rvore esquerda
a 100 200
a-c-g-f-b-e-d
Central direita
.Percorre a sub-rvore direita
83 120 150 230
.Visita a raiz
.Percorre a sub-rvore esquerda
b c .Central esquerda?

g-c-f-a-e-b-d 83 - 100 - 120 - 130 - 150 - 200 - 230

Ps-Fixado direita
.Percorre a sub-rvore direita
d e f g .Central direita?
.Percorre a sub-rvore esquerda
.Visita a raiz 230 - 200 - 150 - 130 - 120 - 100 - 83
g-f-c-e-d-b-a
 Exemplo: expresso aritmtica Percorrer: Pr-Fixado Esquerda
+
6
raiz q 7
* / 1 nil
nil
q qq = nil nil
Central E A B C D
Pr-fixado E nil
.esquerda 2 5 3
.raiz Ps-Fixado E q 4
.raiz q
.esquerda .esquerda 2
.direita .direita
.direita 3 4 6 7 5
A * B + C / D .raiz
1
+ * A B / C D A B * C D / +
1- 2 - 3 - 4 - 5 ...

Percorrer: Pr-Fixado Esquerda Recursividade em rvores

a
raiz
proc preFixado(a: Pnodo);
var paux: Pnodo; {apontador auxiliar} a
s: Pilha; {simbolizando a pilha}
incio
push(s,a); {coloca na pilha o endereo da raiz} raiz
enquanto (consulta(s,paux)=true)
b c
{enquanto houver alguma coisa na pilha}
sub-rvore
faa incio sub-rvore
direita
se(pop(s,paux)=true) {tira endereo do topo da pilha} esquerda sub-rvore
ento incio direita
visita(paux); {efetua a operao desejada no nodo} d e f g
push(s,paux.dir); {empilha raiz da sub-rvore direita} sub-rvore
push(s,paux.esq) {empilha raiz da sub-rvore esquerda} esquerda
fim
fim
h i
fim preFixado;
rvores
Pr-Fixado Esquerda Ps-Fixado a Esquerda
proc posFixado(a: pNodo);
proc preFixado(a: pNodo);
{percurso pos-fixado esquerdo, usando recursividade}
{percurso pr-fixado esquerdo, usando recursividade}
incio
incio
se a <> nil {existe a rvore ou sub-rvore}
se a <> nil {existe a rvore ou sub-rvore}
ento incio
ento incio
posFixado(a.esq); {percurso da sub-rvore esquerda}
visita(a); {executa operao}
posFixado(a.dir) {percurso da sub-rvore direita}
preFixado(a.esq); {percurso da sub-rvore esquerda}
visita(a); {executa operao}
preFixado(a.dir) {percurso da sub-rvore direita}
fim
fim
fim posFixado; a
fim preFixado;

a 7
1
3 6
2 5

3 4 6 7 1 2 4 5

Central Esquerda TAD: Operaes sobre rvores Binrias (parcial)

proc central(a: pNodo);

proc inicializa(var a: Pnodo);
{percurso central esquerda, usando recursividade}
// cria uma rvore vazia
incio proc insereRaiz(var a: Pnodo; info: Dados);
se a <> nil {existe a rvore ou sub-rvore} // aloca nodo raiz e insere dado
proc insereEsq(var a: Pnodo; InfoPai, InfoFilho: Dados);
ento incio
// insere um nodo na sub-rvore esquerda
central(a.esq); {percurso da sub-rvore esquerda} proc insereDir(var a: Pnodo; InfoPai, InfoFilho: Dados);
visita(a); {executa operao} // insere um nodo na sub-rvore direita
proc preFixado(a: pNodo);
central(a.dir) {percurso da sub-rvore direita} // percurso pr-fixado esquerdo, usando recursividade
fim proc posFixado(a: pNodo);
// percurso ps-fixado esquerdo, usando recursividade
fim central;
proc central(a: pNodo);
a // percurso central esquerda, usando recursividade
proc constroi(var a: Pnodo);
4
// constri uma (sub)rvore e devolve o endereo da raiz
funo copia(a: Pnodo):Pnodo;
2 6 // monta uma cpia de uma rvore a, devolvendo o endereo da raiz

1 3 5 7