Árvores

Árvores
Árvores
Conceitos sobre Árvores
Servem para representar estruturas hierarquiza-
Notas de aula da disciplina IME 04-10820 das, notadamente Bancos de Dados.
ESTRUTURAS DE DADOS I Def: Uma árvore enraizada T é um conjunto finito
de vértices (nós) tais que:
Paulo Eustáquio Duarte Pinto -T é um conjunto vazio, ou
(pauloedp arroba ime.uerj.br) -existe um nó r (raiz) tal que os demais nós
são particionados em m > 1 conjuntos não
vazios, as subárvores de r e sendo cada um
desses conjuntos uma árvore.
maio/2013
Árvores Árvores
Representações de Árvores Representações de Árvores
a) Diagramas de Inclusão: c) Diagramas de Barras:

A A-------------
B C---------
C
D D-----
E
B---------
b) Representação Hierárquica: E---------
A d) Parênteses Aninhados:
C B E ( A ( C ( D ) ) ( B ) ( E ) )
D
Árvores Árvores
Conceitos Conceitos
A
A
C B E
C B E
D
D
A está no nível 1; D, no nível 3;
A é pai de C, B, E; C é pai de D; A é avô de D;
A altura da árvore é 3;
B é filho de A; D é filho de C; B é tio de D;
O caminho entre A e D tem comprimento 2; entre
B é irmão de C; D é sobrinho de E; D e E, comprimento 3;
D, B e E são folhas; A e C são nós intermediários; Uma Floresta é um conjunto de árvores;
1
Árvores binárias Árvores binárias
Árvores Binárias Conceitos de Árvores Binárias

Def: Uma árvore binária enraizada T é um +
conjunto finito de vértices (nós) tais que: * -
-T é um conjunto vazio, ou A B C /
-existe um nó r (raiz) tal que os demais nós
são particionados em 2 conjuntos, as subár- D E
vores esquerda (Te) e direita (Td) de r, sendo
cada uma delas uma árvore binária. Em uma árvore estritamente binária cada nó tem 0
Exemplo: ou 2 filhos.
A
Em uma árvore binária completa as subárvores
C E nulas estão todas nos dois últimos níveis da árvore;
D Em uma árvore binária cheia as subárvores (ares-

B F tas, links) nulas estão todas no último nível;
Exercícios Exercícios
+ +
* - * -
A B C / A B C /
D E D E
Quantos nós tem uma árvore binária cheia de

Desenhar todas as árvores binárias distintas para altura h?
as chaves A B e C.
Qual o número mínimo de nós em uma árvore
binária completa de altura h?
Desenhar uma árvore estritamente binária com 11
nós e altura 5. Quantas formas de árvores binárias completas
distintas existem contendo n nós?
Conceitos Conceitos
+ +
* - * -
A B C / A B C /
D E D E
O número de subárvores nulas (links nulos) em uma árvore

binária com n nós é n+1. Altura h de uma árvore árvore binária completa com n nós:
Existe um único caminho entre dois nós de uma árvore. 2h - 1 ≤ n ≤ 2h - 1 ⇒ h = log2 n + 1 = = log2 (n+1)
A árvore binária que representa uma expressão aritmética
é uma árvore estritamente binária com os operandos nas
Altura de uma árvore binária com n nós:
folhas e operadores em nós intermediários.
log2 n + 1 ≤ h ≤ n
2
Representação Percursos
+ +
* - * -
A B C / A B C /
D E D E
Percursos em árvores binárias são formas sistemáticas de

Representação computacional: percorrer (visitar) os nós da árvore.
le ld -Percurso em nível
chave
-Percurso em pré-ordem
-Percurso in-ordem (ordem simétrica)
Type Arv = ↑No; -Percurso em pós-ordem
No = Record ...
chave: char; le, ld: Arv
End;
Árvores Árvores
Percursos Percurso em nível

+ +
* - * -
A B C / A B C /
D E D E
Percurso em nível: Percurso_nivel;
a idéia é visitar um nível a cada vez, de cima Esvazia Q; Enfila (T);
Enquanto (f ≠ 0):
para baixo e da esquerda para a direita
p ← primeiro elemento da fila;
Visita (p);
↑.le);
Enfila (p↑
+ * - A B C / D E ↑.ld);
Enfila (p↑
p ← Desenfila();
Fe;
Fim;

Percurso em nível
Exercício
+
* - +
A B C / + + * -
D E * - * A B /
Percurso_nivel; - A B -
Esvazia Q; Enfila (T); A B C / A C D
Enquanto (f ≠ 0):
p ← primeiro B C / B E
elemento da fila;
Visita (p); C / C
↑.le);
Enfila (p↑
/ / Exercício: mostrar a situação da fila na Busca em
↑.ld);
Enfila (p↑ nível da árvore acima.
p ← Desenfila (); D E D
Fe;
Fim; E E
3
Construção de árvore cheia de altura h Exercício

1 1
2 3 2 3
4 5 6 7
4 5 6 7
Constroi(h):
Esvazia a fila; Alocar(T); Enfila(T); n ← 2h-1 - 1
T↑↑.c ← 1; T↑ ↑.le ← Nil; T↑↑.ld ← Nil; i ← 1; 8 9 10
Enquanto (f ≠ 0):
p ← primeiro elemento da fila;
Alocar (q); q↑ ↑.c ← i+1; q↑ ↑.le ← Nil; ↑.ld ← Nil;
q↑
Alocar (s); s↑ ↑.c ← i+2; s↑ ↑.le ← Nil; ↑.ld ← Nil;
s↑
↑.le ← q; p↑
p↑ ↑.ld ← s; i ← i+2; Exercício: modificar o algoritmo de criação de ár-
Se (i ≤ n) Então
Enfila (q); Enfila (s);
vore binária cheia, para a criação de uma árvore
Fs; binária completa, para dado n.
p ← Desenfila ();
Fe;
Fim;
Percursos Percurso em pré-ordem

+ +
* - * -
A B C / A B C /
D E D E
Pré-Ordem;
Percurso em pré-ordem: Esvazia P; PUSH (T);
a idéia é visitar, sistematicamente, a raiz, Enquanto (topo ≠ 0):
em seguida toda a subárvore esquerda e depois p ← POP (); Visita (p);
toda a subárvore direita (RED). PUSH (p↑↑.ld);
PUSH (p↑↑.le);
Fe; A
+ * A B - C / D E Fim;
B
+ * A *
+
-
Percurso em pré-ordem Percurso em pré-ordem

+ +
* - * -
A B C / A B C /
D E Pré-Ordem; D E
Pré-Ordem;
Esvazia P; PUSH (T); Esvazia P; PUSH (T);
Enquanto (topo ≠ 0): Enquanto (topo ≠ 0):
p ← POP (); Visita (p); p ← POP (); Visita (p);
PUSH (p↑↑.ld); PUSH (p↑↑.ld);
PUSH (p↑↑.le); PUSH (p↑↑.le);
Fe; Fe;
Fim; Fim;
+ * A B- C C + * A B- C/D D
/ E
4
Percursos
Exercício
+
+
* -
* -
A B C / A B /
D E
Pré-Ordem; C D
Esvazia P; PUSH (T);
Enquanto (topo ≠ 0): E
p ← POP (); Visita (p);
PUSH (p↑↑.ld);
PUSH (p↑↑.le); Exercício: mostrar a situação da pilha na Busca em
Fe; pré-ordem da árvore acima.
Fim;
+ * A B- C/DE
Percursos Percursos em ordem simétrica

+ +
* - * -
A B C / A B C /
D E In-Ordem; D E
Percurso em ordem simétrica (in-ordem): Esvazia S; p ← T;
a idéia é visitar, sistematicamente, toda a Enquanto (p ≠ Nulo) Ou (topo ≠ 0):
Enquanto (p ≠ Nulo):
subárvore esquerda, a raiz, e em seguida toda a
PUSH (p); p ← p↑↑.le;
subárvore direita (ERD). Fe;
p ← POP (); Visita (p); p ← p↑↑.ld;
Fe; A
A * B + C - D / E Fim; A *
+
Percurso em ordem simétrica Percurso em ordem simétrica

+ +
* - * -
A B C / A B C /
In-Ordem;
In-Ordem; E E
D Esvazia S; p ← T; D
Esvazia S; p ← T;
Enquanto (p ≠ Nulo) Ou (topo ≠ 0):
Fe;
Fe;
Fe;
Fe;
Fim;
Fim; A *B B A * B +C C
+ -
5
Percurso em ordem simétrica Percurso em ordem simétrica

+ +
* - * -
A B C / A B C /
In-Ordem; E In-Ordem; E
D D
Esvazia S; p ← T; Esvazia S; p ← T;
Enquanto (p ≠ Nulo) Ou (topo ≠ 0): Enquanto (p ≠ Nulo) Ou (topo ≠ 0):
Enquanto (p ≠ Nulo): Enquanto (p ≠ Nulo):
PUSH (p); p ← p↑↑.le; PUSH (p); p ← p↑↑.le;
Fe; Fe;
p ← POP (); Visita (p); p ← p↑↑.ld; p ← POP (); Visita (p); p ← p↑↑.ld;
Fe;
Fe; Fim;
Fim; A * B +C - D D A * B +C - D / E
/ E
Percursos
Exercício +
E * -
B F A B C /
A C I
D E
D H Percurso em pós-ordem:
G a idéia é visitar, sistematicamente, toda a
subárvore esquerda, em seguida toda a subárvore
direita e, por fim, a raiz (EDR).
Exercício: mostrar a situação da pilha na Busca
in-ordem da árvore acima.
A B * C D E / - +
Percurso em pós-ordem Percurso em pós-ordem

+ +
* - * -
A B C / A B C /
Pos-Ordem; Pos-Ordem;
Esvazia S; p ← T; D E Esvazia S; p ← T; D E
PUSH (p, 1); p ← p↑ ↑.le; PUSH (p, 1); p ← p↑ ↑.le;
Fe; Fe;
Enquanto (p = Nulo) E (topo ≠ 0): Enquanto (p = Nulo) E (topo ≠ 0):
(p, vez) ← POP(); (p, vez) ← POP();
↑.ld ≠ Nulo) Então
Se (vez = 1) e (p↑ ↑.ld ≠ Nulo) Então
Se (vez = 1) e (p↑
PUSH(p, 2); p ← p↑ ↑.ld; A,1 PUSH(p, 2); p ← p↑ ↑.ld; B,1
Senão Senão
Visita (p); p ← Nulo; *,1 Visita (p); p ← Nulo; *,2
Fe; Fe;
Fe;
A +,1 Fe;
AB
*,1 +,1
Fim; Fim;
6

+ +
* - * -
A B C / A B C /
Fe; Fe;
Se (vez = 1) e (p↑ ↑.ld ≠ Nulo) Então
Se (vez = 1) e (p↑
PUSH(p, 2); p ← p↑ ↑.ld; PUSH(p, 2); p ← p↑ ↑.ld; C,1
Senão Senão
Visita (p); p ← Nulo; Visita (p); p ← Nulo; -,1
Fe; Fe;
Fe;
AB * +,1 Fe;
A B * +,1
C +,2
Fim; Fim;

+ +
* - * -
A B C / A B C /
Fe; Fe;
Se (vez = 1) e (p↑
D,1 ↑.ld ≠ Nulo) Então
Se (vez = 1) e (p↑
E,1
PUSH(p, 2); p ← p↑ ↑.ld; /,1 PUSH(p, 2); p ← p↑ ↑.ld; /,2
Senão Senão
Visita (p); p ← Nulo; -,2 Visita (p); p ← Nulo; -,2
Fe; Fe;
Fe;
A B * C -,1
D +,2 Fe;
A B * C D /,1
E +,2
Fim; Fim;
Percurso em pós-ordem
+
Exercício
* - +
A B C / * -
Pos-Ordem;
A B /
Esvazia S; p ← T; D E
Enquanto (p ≠ Nulo): C D
PUSH (p, 1); p ← p↑ ↑.le;
Fe; E
Enquanto (p = Nulo) E (topo ≠ 0):
(p, vez) ← POP();
Se (vez = 1) e (p↑
PUSH(p, 2); p ← p↑ ↑.ld; Exercício: mostrar a situação da pilha na Busca
Senão em pós-ordem da árvore acima.
Visita (p); p ← Nulo;
Fe;
Fe;
Fim;
A B *C D E / - +
7
Recursão Recursão
Fatorial(p);
É uma técnica de solução de problemas Se (p = 0) Então
(construção de algoritmos) que procura a Retornar 1
solução subdividindo o problema em sub- Senão
problema(s) menor(es), de mesma nature- Retornar p.Fatorial(p-1);
Fim;
za, e compõe a solução desses subproble-
mas, obtendo uma solução do problema ori-
ginal. Fib(p);
Se (p ≤ 1 ) Então
Retornar p
Senão
DIVIDIR PARA CONQUISTAR!!! Retornar Fib(p-1)+Fib(p-2);
Fim;
Recursão Recursão
Visões sobre Recursão: Visões sobre Recursão:
a) Solução de problemas de trás para frente c) Equivalente procedural de Recorrências

enfatiza-se os passos finais da solução, após ter-se Recorrências são maneiras de formular funções para n,
resolvido problemas menores. Mas a solução de problemas utilizando resultados da mesma função para valores menores
que n. Além disso uma recorrência deve exibir resultados
pequenos (“problemas infantís”) tem que ser mostrada.
específicos para determinados valores.
b) Analogia com a “Indução finita” d) Estrutura de um procedimento recursivo

Indução Finita: prova-se resultados matemáticos gerais Procedimentos recursivos “chamam a sí mesmos”. Um
supondo-os válidos para valores inferiores a n e procedcimento recursivo começa com um “Se”, para separar
demonstrando que o resultado vale também para n. Além subproblemas ‘infantís” dos demais. O procedimento chama
disso, mostra-se que o resultado é correto para casos a si mesmo pelo menos uma vez. Sempre há uma chamada
particulares. externa.
Recursão Recursão
Árvore de recursão para Fatorial
Dinâmica da execução de um procedimento
X ← Fatorial(5) 5
recursivo. 24.5=120
Sempre que uma chamada recursiva é executada, o 4 6.4=24

sistema operacional empilha as variáveis locais e a Fatorial(p);
Se (p = 0) Então
instrução em execução, desempilhando esses Retornar 1 3 2.3=6
elementos no retorno da chamada. Senão
Retornar p.Fatorial(p-1);
Fim; 2 1.2=2
Chamadas recursivas podem ser expressas através

de uma árvore de recursão. 1 1.1=1
0 1
8
Recursão
Exercício MergeSort em Vetores:
Este é um importante método de ordenação, cuja
idéia recursiva é a seguinte:
Impressão de lista Encadeada
a) Dividir o vetor ao meio e ordenar separadamente cada
um dos subvetores.
Exercício: b) Fazer Merge dos subvetores ordenados.
Escrever um algoritmo recursivo para c) O problema infantil é um subvetor de tamanho igual ou
inferior a 1 quando, para ordená-lo, nda deve ser feito.
imprimir uma lista encadeada em ordem reversa.
V
V1
V2
Merge
Recursão Recursão
MergeSort em Vetores:
MergeSort: exemplo
MergeSort (e, d);
1 2 3 4 5 6
Se (d > e) Então
i ← (e+d)/2; P R I O M G
MergeSort(e, i); MergeSort(i+1, d); P R I O M G
Merge(e, i, d); P R O M
Fim; P O
R M
P R M O
O algoritmo de Merge a ser usado é aquele baseado em 3 I G
loops. O Merge deve ser feito em um vetor auxiliar, que I P R G M O
depois é copiado para o vetor inicial. G I M O P R
Recursão Exercício
MergeSort: exemplo da árvore de recursão
GIMOPR
MergeSort
1 6 3 PRIOMG
IPR GMO
Exercício:
1 3 2 PRI 4 6 5 OMG
Mostrar a árvore de recursão do
PR MO
Mergesort para o MIXSTRING (10 letras).
1 2 1 PR 3 3 - I 4 5 4 OM 6 6 - G
1 1 - - P 2 2 - R 4 4 - - O 5 5 - M
9
Percursos recursivos
Análise do Mergesort:
+
* -
Complexidade:
Pior caso = melhor caso = caso médio: O(n log n) A B C /
Estabilidade (manutenção da ordem relativa de D E

chaves iguais):
A maioria dos percursos em árvores binárias são intrinse-
Algoritmo estável camente recursivos, pois cada percurso se constitui em
Memória adicional: visitar nós especiais e subárvores (problemas menores).
Vetor de tamanho n para merge intermediário -Percurso em pré-ordem
Usos especiais: -Percurso in-ordem (ordem simétrica)
Ordenação de listas encadeadas -Percurso em pós-ordem
Minimização de I/O para arquivos grandes.
O problema infantil é visitar uma árvore nula(nada é feito).
Percursos recursivos Percurso recursivo em pré-ordem

+
+
* -
* -
A B C /
A B C /
D E
D E
Percurso em pré-ordem (RED):
-Visitar a raiz, Pré-Ordem (p);
+
-Visitar a subárvore esquerda em pré-ordem Se (p ≠ Nulo) Então
Visita (p); * -
-Visitar a subárvore direita em pré-ordem. Pré-Ordem (p↑ ↑.le);
Pré_Ordem (p↑ ↑.ld); A B C /
Fim;
D E
+ * A B - C / D E Externamente:
Pré-Ordem(T); + * AB -C /DE
Percursos recursivos Percurso recursivo em ordem simétrica

+ +
* - * -
A A B C /
B C /
E D E
D
Percurso in-ordem (ERD):
+
-Visitar a subárvore esquerda in-ordem, In-Ordem (p);
Se (p ≠ Nulo) Então
-Visitar a raiz, * -
In-Ordem (p↑ ↑.le);
-Visitar a subárvore direita in-ordem. Visita (p);
In-Ordem (p↑ ↑.ld); A B C /
Fim;
D E
A * B + C - D / E Externamente:
In-Ordem(T); A * B +C -D / E
10
Percursos recursivos Percurso recursivo em pós-ordem

+ +
* - * -
A B C / A B C /
D E D E
Percurso em pós-ordem (EDR):
-Visitar a subárvore esquerda em pós-ordem, Pós-Ordem (p);
+
-Visitar a subárvore direita em pós-ordem, Se (p ≠ Nulo) Então
Pós-Ordem (p↑ ↑.le); * -
-Visitar a raiz. Pós-Ordem (p↑↑.ld);
Visita (p); A B C /
Fim;
D E
A B * C D E / - + Externamente:
Pós-Ordem(T); AB * C DE / - +
Exercício Árvores Binárias de Busca

Percursos recursivos São árvores constuídas com a regra forçada de
que, para cada nó da árvore, todas as chaves da
+ subárvore esquerda são menores que a chave desse
* - nó e todas as da subárvore direita, maiores.
A B C / Exemplo:
D E 20
15 80
Exercício: Dada uma expressão aritmética
com operadores binários, representada em uma 2 16 51 101
árvore binária, escrever a expressão equivalente
99 213
totalmente parentisada.
Árvores Binárias de Busca

Exercício Inserções: sempre é possível inserir uma chave não
existente, através de um processo simples, top-down.
Exercício:
Exemplo: Árvore dos Signos
Desenhar todas as ABBs distintas para as chaves: CAP, AQU, PEI, ARI, TOU, GEM, CAN, LEA, VIR, LIB, ESC, SAG
A, B, C e D, com A na raiz.
CAP
AQU PEI
ARI GEM TOU
CAN ESC LEA SAG VIR
LIB
11
Árvores Binárias de Busca

Exercício Convenção de nó terminal: pode-se usar um nó
pré-alocado, z, como nó final, em substituição às
subárvores nulas.
Desenhar ABBs para as chaves incluídas nas seguin-
tes ordens: T
20
a) AQU, ARI, CAN, CAP, ESC, VIR, TOU, SAG, GEM, PEI, LEA, LIB 15 80
2 16 51 101
b) AQU, VIR, ARI, TOU, CAN, SAG, CAP, PEI, LIB, ESC, GEM, LEA
99 213
Inserção uma ABB (com nó terminal).

Busca em uma ABB (com nó terminal).
Inicialização;
Alocar (z); ↑.le ← z;
z↑ ↑.ld ← z;
z↑ T ← z;
Busca(k); Fim;
↑.chave ← k; p ← T;
z↑ Inserçao(k);
↑.chave ≠ k):
Enquanto (p↑ ↑.chave ← k; p ← T; f ← T;
z↑
↑.chave) Então
Se (k < p↑ Enquanto (p↑↑.chave ≠ k):
p ← p↑↑.le f ← p;
Se (k < p↑↑.chave) Então p ← p↑ ↑.le
Senão Senão p ← p↑↑.ld;
p ← p↑↑.ld; Fe;
Fe; Se (p = z) Então
Se (p = z) Então Alocar(p); p↑↑.chave ← k; p↑ ↑.le ← z; p↑ ↑.ld ← z;
p ← Nulo; Se (T = z) Então T ← p
Senão Se (k < f↑↑.chave) Então f↑
↑.le ← p
Retornar p; Senão ↑.ld ← p;
f↑
Fim; Fs;
Fim;
Propriedade fundamental de uma ABB: Exercício

O percurso in-ordem obtem as chaves ordenadas.
Criar uma ABB para o MIXSTRING (sem repe-
Exemplo: tições) e checar a propriedade fundamental de uma
20 ABB.
15 80
2 16 51 101
99 213
In-ordem: 2 15 16 20 51 80 99 101 213

Essa propriedade conduz ao método de ordenação
TreeSort!!!
12
Exercício: Altura de uma ABB:
colocar as chaves A,B,C,D,E,F,G,H,I,J,K,L na Altura mínima: árvore completa.

estrutura abaixo, tal que tenhamos uma ABB. h = log2 n + 1 = = log2 (n+1)
20 2
15 80 15
2 16 51 101
99 213 101
Altura máxima: árvore degenerada. h = n 213
Altura média (Knuth 73): h ≈ 1,4 log2 n
Enumeração de ABBs.
Exercício:
T(n) = número de ABBs distintas para n chaves
T(0) = 1; T(1) = 1; T(2) = 2; T(3) = 5; Calcular T(6) = número de distintas ABBs c/ 6

chaves:
T(n) = ∑Ti.T(n-1-i), 0 ≤ i < n; a) usando a recorrência
b) usando o número de Catalão.
Idéia da recorrência: fixar progressivamente cada uma
das n chaves como raiz e somar os produtos do número de
ABBs distintas à esquerda com i chaves, pelo número de
ABBS distintas à direita com n-1-i chaves.
T(n) = Comb(2n, n)/(n+1). (Número de Catalão!!)
Árvore de Decisão da Pesquisa Binária

Árvore de Decisão da Pesquisa Binária (ADPB) (ADPB)
A Pesquisa Binária pode ser melhor compreendida por uma
ABB, que representa o processo de busca no vetor. A Árvore de Decisão da Pesquisa Binária é uma árvore
binária completa e pode ser construida recursivamente.
Exemplo: 1 2 3 4 5 6 7 8 9
B D H K M P R T V Exemplo: 1 2 3 4 5 6 7 8 9
B D H K M P R T V
(1+9)/2 = 5
(1+4)/2= 2 M M
(6+9)/2=7
< >
D R D R
(1+1)/2= 1 (3+4)/2= 3 (6+6)/2=6 (8+9)/2=8
< > < >
B H P B H P T
T
(4+4)/2= 4
> > (9+9)/2=9
K V K V
13
Construção Recursiva da ADPB
Exercício:
Constroi(e, d, p);
Se (e > d) Então
p ← Nulo
Desenhar a ADPB para n = 11.
Senão
i ← (e+d)/2;
Alocar(p); p↑↑.chave ← V[i];
↑.le);
Constroi(e, i-1, p↑
↑.ld);
Constroi(i+1, d, p↑
Fim;
Externamente:
Constroi(1, n, T);
Árvores Balanceadas
Para evitar a degeneração em ABB, foram cria- Árvores AVL (Adel’son-Vels’ii-Landis)
das as árvores balanceadas. A idéia é a de, a
Árvores binárias onde, para cada nó, a altura das
cada inserção em uma ABB, checar se a árvore
duas subárvores difere no máximo em 1.
está tendendo à degeneração e acertar ime-
diatamente, se necessário (balancear a árvore).
K -
O balanceamento é baseado na altura.
H - N 0
Tipos de árvores balanceadas:
AVL C 0 I + L + - P
B/B+
Rubronegras B - F 0 J 0 M 0 O 0
2-3, etc A 0 D 0 G 0
Balanceamento de AVL's
Caso 1 - Rotação Simples
Exercício: Sit. Inicial: Desbalanceamento Rotação Simples
a) Desenhar uma árvore AVL de altura 6,

com o menor número de nós possível.
Na + Na ++ Nb 0
b) Desenhar todas as AVLs para as chaves
A, B, C, D. α α Nb + Na 0 δ’
Nb 0
(h) (h)
β δ’ (h+1)
β δ α β
(h) (h) (h+1) (h) (h)
(h)
14
Árvores binárias Árvores
Balanceamento de AVL's
Árvores AVL
Caso 1 - Rotação Simples - Balanceamento - Caso 2 - Rotação Dupla
Sit. Inicial: Desbalanceamento Rotação Dupla
a) Preservação da ordem de busca
Busca in-ordem antes: α.Na.β β.Nb.δ
δ’
depois: α.Na.β
β.Nb.δ
δ’
Na + Na ++ Nx 0
b) Preservação da altura
Antes: max(h, max(h, h)+1)+1 = h+2
α Nb 0 α Nb - Na 0|- Nb +|0
Depois: max(max(h, h) +1, h+1)+1 = h+2
(h) (h)
c) Balanceamento Nx 0 δ Nx δ α β’ γ’ δ
Subárvores α, β e δ’ balanceadas, por hipótese. -|+ (h)
β γ (h) β’ γ’ (h) (h)
Nós Na e Nb balanceados (esquema); restante da
árvore balanceada, por b). (h-1) (h-1) (h|h-1)(h-1|h) (h|h-1)(h-1|h)
Árvores Árvores
Árvores AVL Árvores AVL

Correção da Rotação Dupla
a) Preservação da ordem de busca
Busca in-ordem antes: α.Na.β
β’.Nx.γγ’.Nb.δ
δ Exercício:
depois: α.Na.β
β’.Nx.γγ’.Nb.δ
δ
b) Preservação da altura
Antes: max(h, max(max(h-1, h-1)+1, h)+1)+1 = h+2 Criar e balancear, passo a passo, o
Depois: max(max(h, h| h-1)+1, max(h-1| h, h)+1)+1 = h+2 MIXSTRING.
c) Balanceamento
Subárvores α, β’, γ’ e δ balanceadas, por hipó-
tese. Nós Nx, Na e Nb balanceados (esquema);
res-tante da árvore balanceada, por b).
Árvores Árvores

Exercício: balancear a árvore abaixo, após a Solução: balancear a árvore abaixo, após a
inserção da chave E. inserção da chave E.
K - K -
H - N 0 F 0 N 0
C 0 I + L + - P C 0 H + L + - P
B - F 0 J 0 M 0 O 0 B - D + G 0 I + M 0 O 0
A 0 D 0 G 0 A 0 E 0
J 0
E
15
Árvores Árvores

Resumo do algoritmo de Inserção/Balanceamento: Resumo do algoritmo de Inserção/Balanceamento:
Busca_Insercao(k, p, h);
Busca_Insercao(k, p, h); ...
Se (p = Nulo) Então {Insere; h ← True;} Senão Se (k > p↑ ↑.chave) Então
Senão Se (k < p↑↑.chave) Então {Busca_Insercao(k, p↑ ↑.ld, h);
{Busca_Insercao(k, p↑ ↑.le, h); Se (h) Então
Se (h) Então ↑.bal):
Caso (p↑
↑.bal):
Caso (p↑ -1: {p↑ ↑.bal ← 0; h ← False;}
1: {p↑ ↑.bal ← 0; h ← False;} 0: {p↑ ↑.bal ← 1; }
0: {p↑ ↑.bal ← -1; } 1: {Se (p↑ ↑.ld↑
↑.bal = 1) Então RotSimplDir(p)
-1: {Se (p↑ ↑.le↑
↑.bal = -1) Então RotSimplEsq(p) Senão RotDuplDir (p);
Senão RotDuplEsq (p); p↑↑.bal ← 0; h ← False;
p↑↑.bal ← 0; h ← False; }
} }
} Senão h ← False;
continua... Fim; continua...
Árvores Árvores

Resumo do algoritmo de Inserção/Balanceamento: Árvores AVL Mínimas
RotSimplEsq(p);
pf ← p↑↑.le;
↑.le ← pf↑
p↑ ↑.ld; pf↑ ↑.ld ← p; p↑ ↑.bal ← 0;
Problema: determinar a maior altura possível para
p ← pf; ↑.bal ← 0;
p↑ h ← False; uma AVL com n chaves.
Fim;
RotDuplEsq(p);
pf ← p↑↑.le; pn ← pf↑ ↑.ld;
↑.ld ← pn↑
pf↑ ↑.le; pn↑
↑.le ← pf; p↑ ↑.le ← pn↑
↑.ld; pn↑
↑.ld ← p;
↑.bal = -1) Então p↑
Se (pn↑ ↑.bal ← 1
Solução: resolver o problema dual:
Senão ↑.bal ← 0;
p↑ Determinar o número mínimo de chaves em uma
↑.bal = 1) Então pf↑
Se (pn↑ ↑.bal ← -1 AVL de altura h.
Senão ↑.bal ← 0;
pf↑
p ← pn; p↑ ↑.bal ← 0; h ← False;
Fim;
Árvores Árvores

Árvores AVL Mínimas Árvores AVL Mínimas
Recorrência: T(h) = Recorrência: T(h) =

núm. mínimo de chaves numa AVL de altura h núm. mínimo de chaves numa AVL de altura h
T(0) = 0; T(1) = 1; T(0) = 0; T(1) = 1;

T(h) = 1 + T(h-1) + T(h-2); T(h) = Fib(h+2)-1; T(h) = 1 + T(h-1) + T(h-2); T(h) = Fib(h+2)-1;
h 0 1 2 3 4 5 6 7 8 9 ⇒ h ≤ 1,4 log n,
T(h) 0 1 2 4 7 12 20 33 54 88 a altura máxima da AVL é 1,4 log n
a altura média da AVL é log n.
Fib(h) 0 1 1 2 3 5 8 13 21 34
16
Árvores Árvores
Árvores B (Bayer) Árvores B (Bayer)

Exemplo de árvore B de ordem 2:
Árvores m-árias de busca (de ordem d) , para
ar-mazenamento em disco, que obedecem a
Regra 1 Árvore é de busca!
quatro regras básicas: Regra 2
Regra 3 L
Regra 4
1) A raiz tem entre 1 e 2d chaves. P S V

2) Nós intermediários têm um mínimo de d chaves C G
e um máximo de 2d chaves.
3) Nó intermediário com k chaves tem k+1 filhos.
4) As folhas estão todas no mesmo nível. A B D E F H I J K M N O Q R T U W X
Árvores Árvores
Árvores B (Bayer) Árvores B (Bayer)

Exercício: Busca na árvore: R
Desenhar uma árvore B de ordem 1, para as L R > L

26 letras do alfabeto, com altura 4.
P T W P <R < T
C G
A B D E F H I J K M N O U V X Y
QR
R S
Árvores Árvores
Árvores B (Bayer) - Inserções Árvores B (Bayer) - Inserções (Regras)

A inserção é sempre feita nas folhas. Isso 1) a inserção é sempre feita numa folha. Se
implica um processo de crescimento de baixo para houver “overflow”, faz-se Split e Promoção.
cima e a necessidade de um método especial de
inserção: Split e Promoção. Ex: Criar árvore B de ordem 2 para:
A E I O U D W Q F R J P K T C B G H L M S V Z N Y X
Exemplo: Criar Árvore B de ordem 2 para E B C A D.
PROMOÇÃO C +U I I +R
+D,W,Q,F
+D
A B C E A E I O
A B D E A E O U A D E F O Q U W
SPLIT
17
Árvores Árvores
Árvores B (Bayer) - Inserções Árvores B (Bayer) - Inserções

Ex: Criar árvore B de ordem 2 para: Ex: Criar árvore B de ordem 2 para:
A E I O U D W Q F R J P K T C B G H L M S V Z N Y X A E I O U D W Q F R J P K T C B G H L M S V Z N Y X
+K
+U I +D,W,Q,F I +R I R
A E I O A E O U A D E F O Q U W I O R
A D E F J O P Q U W
I R A D E F J K P Q U W
+J,P
I R +K
A D E F O Q U W +T I O R
+C
A D E F J O P Q U W
A D E F J K P Q T U W
Árvores Árvores

Ex: Criar árvore B de ordem 2 para: Ex: Criar árvore B de ordem 2 para:
A E I O U D W Q F R J P K T C B G H L M S V Z N Y X A E I O U D W Q F R J P K T C B G H L M S V Z N Y X
D I O R D I O R U
+V
A C E F J K P Q T U W A B C E F G H J K L M P Q S T V W
O
+B,G,H,L,M, S D I O R +V
D I R U
A B C E F G H J K L M P Q ST U W
A B C E F G H J K L M P Q S T V W
Árvores Árvores
1) a inserção é sempre feita numa folha. Se Exercício:

houver “overflow”, faz-se Split e Promoção.
2) Se houver “overflow” em nó intermediário,
Criar, passo a passo, árvores B de ordens 1 e
faz-se split e promoção no nível intermediário e
2 para o MIXSTRING.
redis-tribuição de subárvores.
+1 / +1
x
x x x x x x x x x
2d+1 / 2d+2 d / d+1 d / d+1
18
Árvores Árvores
Árvores B (Bayer) - Inserções Árvores B

Porque se usa árvore m-ária em disco? Resumo do algoritmo de Inserção
R: Para otimizar acesso a disco. Quando se acessa

disco para leitura ou gravação, sempre se trabalha Atualização;
com uma trilha inteira devido ao “seek” do disco. T ← Nulo;
Enquanto houver chaves:
Ler(x);
A ordem da árvore é calculada a partir do tamanho BuscaInserção(x, T, h, u);
da trilha. Se (h) Então
q ← T;
Alocar(T); T↑↑.m ← 1; ↑.le ← q; Vv[1] ← u;
T↑
}
Ex: tamanho da trilha = 10k Fe;
Fim;
tamanho da chave + link = 50
→ d = 10000/2*50 = 100 continua...
Árvores Árvores
Árvores B Árvores B
Resumo do algoritmo de Inserção: Resumo do algoritmo de Inserção:
Busca_Insercao(k, p, h, v);
Se (p = Nulo) Então {v.c ← x; v.ld ← Nulo;}
Inserçao;
Senão
↑.m < 2d) Então
Se (p↑
i ← PB(x, p);
↑.m++; h ← False; Faz shift em Vv; Vv[i] ← u;
p↑
Se (i ≠ Nulo) Então h ← False
Senão
Senão {
Alocar(b);
Se (i = 0) Então q ← p↑↑.le
v ← item a ser promovido;
Senão q ← p↑↑.Vv[i].ld;
Transfere a metade direita de p para b;
Busca_Insercao(x, q, h, u);
Acerta a metade esquerda de p e limpa sua metade direita;
Se (h) Então Inserçao;
↑.m ← d; b↑
p↑ ↑.m ← d; b↑ ↑.le ← v.ld; v.ld ← b;
}
}
}
Fim;
Fim;
continua...
Árvores Árvores

Árvores B Mínimas Árvores B Mínimas - Estrutura da árvore
1
Problema: determinar a maior altura possível para
2
uma árvore B, ordem d, com n chaves.
d
d h
Solução: resolver o problema dual: d .d+1.. d d .d+1.. d

Determinar o número mínimo de chaves em uma
árvore B de ordem d e altura h.
d d .d+1.. d
d .d+1..
19
Árvores Árvores

Árvores B Mínimas Árvores B Máximas
Solução: resolver o problema dual: determinar o
número mínimo de chaves em uma árvore B de
ordem d e altura h. Problema: determinar a menor altura possível para
uma árvore B, ordem d, com n chaves.
n = 1 + 2(d + d(d+1) +... +d(d+1)(h-2) ) =
= 1 + 2d((d+1)(h-1) -1)/(d+1-1) =
2(d+1)(h-1) -1 Solução: resolver o problema dual:
⇒ h-1 = log d+1 (n+1)/2 ou Determinar o número máximo de chaves em uma
árvore B de ordem d e altura h.
h ≈ log d+1 (n+1)/2
Árvores Árvores

Árvores B Máximas - Estrutura da árvore Árvores B Máximas
Solução: resolver o problema dual: determinar o
2d número máximo de chaves em uma árvore B de
..2d+1..
ordem d e altura h.
2d
2d h
n = 2d + 2d(2d+1) + ... +2d(2d+1)(h-1) ) =
2d 2d
= 2d((2d+1)h -1)/(2d+1-1) = (2d+1)h -1
.2d+1.. 2d .2d+1.. 2d
⇒
h = log 2d+1 (n+1)
2d .2d+1.. 2d 2d .2d+1.. 2d
Árvores Árvores

Árvores B - Alturas máxima e mínima Regras para Deleções
1. Se a chave está na folha e não há

“underflow”, a chave é deletada na folha.
ÁRVORE MÍNIMA ÁRV. MÁXIMA
n\d 10 50 60 10 50 60 2. Se a chave está na folha e há “underflow”,
faz-se “fusão” ou “recombinação”.
102 2 2 1 2 2 1
103 4 3 2 4 3 2 3. Se a chave está em nó intermediário, substitui
a mesma pela sucessora(na folha) e elimina esta.
106 6 4 3 6 4 3
4. Se ocorrer “underflow” em nó intermediário,
mínima ~ máxima valores baixos !!! faz-se “fusão” ou “recombinação” no nível.
20
Árvores Árvores
Árvores B+ Árvores B+
Arquivos Sequenciais Indexados Árvores B+ de ordem 2
chaves (índice)
chaves + dados J
C F O S V
A B C D E F H I J M N O Q R S U V X Y
Árvores Árvores
Árvores B+ - Inserções Árvores B+
Semelhante à inserção na árvore B. A diferença Ex: Criar árvore B de ordem 2 para:

é que, nos splits de folha, a chave promovida A E I O U D W Q F R J K T C B
tam-bém permanece na folha.
Exemplo: Criar Árvore B+ de ordem 2 para E B C A D.

+U I +D,W,Q,F I +F
PROMOÇÃO C
+D A E I O A E I O U A D E I O Q U W
A B C E
A B C D E
SPLIT
Árvores Árvores
Ex: Criar árvore B+ de ordem 2 para: Ex: Criar árvore B+ de ordem 2 para:
A E I O U D W Q F R J K T C B A E I O U D W Q F R J K T C B
+U I +D,W,Q I +F E I R
A E I O
A E I O U A D E I O Q U W
A D E F I O Q R U W
E I +J E I R
+R +K
A D E F I O Q U W
A D E F I J O Q R U W
21
Árvores Árvores
Ex: Criar árvore B+ de ordem 2 para: Ex: Criar árvore B de ordem 2 para:
A E I O U D W Q F R J K T C B A E I O U D W Q F R J K T C B
E I O R C E I O R
+B
A D E F I J K O Q R U W A B C D E F I J K O Q R T U W
I
+T,C E I O R +B
C E O R
A C D E F I J K O Q R T U W
A B C D E F I J K O Q R T U W
Árvores Árvores
Árvores B+ - Inserções Árvores B+ - Inserções

1) a inserção é sempre feita numa folha. Se
houver “overflow”, faz-se Split e Promoção, Exercício:
mantendo a chave promovida na folha.
2) Se houver “overflow” em nó intermediário,
Criar, passo a passo, árvores B+ de
faz-se split e promoção no nível intermediário e
ordens 1 e 2 para o MIXSTRING.
redis-tribuição de subárvores.
+1 / +1
x
x x x x x x x x x
2d+1 / 2d+2 d / d+1 d / d+1
Árvores
FIM
22

Árvores

Enviado por

Dados do documento

Descrição original:

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Árvores

Enviado por

Direitos autorais:

Formatos disponíveis

Árvores

Representações de Árvores Representações de Árvores

a) Diagramas de Inclusão: c) Diagramas de Barras:

D, B e E são folhas; A e C são nós intermediários; Uma Floresta é um conjunto de árvores;

Árvores Binárias Conceitos de Árvores Binárias

D Em uma árvore binária cheia as subárvores (ares-

Árvores binárias Árvores binárias

Quantos nós tem uma árvore binária cheia de

Árvores binárias Árvores binárias

O número de subárvores nulas (links nulos) em uma árvore

Percursos em árvores binárias são formas sistemáticas de

Percursos Percurso em nível

Árvores binárias Árvores binárias

Construção de árvore cheia de altura h Exercício

Árvores binárias Árvores binárias

Percursos Percurso em pré-ordem

Árvores binárias Árvores binárias

Percurso em pré-ordem Percurso em pré-ordem

Árvores binárias Árvores binárias

Percursos Percursos em ordem simétrica

Árvores binárias Árvores binárias

Percurso em ordem simétrica Percurso em ordem simétrica

Percurso em ordem simétrica Percurso em ordem simétrica

Árvores binárias Árvores binárias

Árvores binárias Árvores binárias

Percurso em pós-ordem Percurso em pós-ordem

Percurso em pós-ordem Percurso em pós-ordem

Árvores binárias Árvores binárias

Percurso em pós-ordem Percurso em pós-ordem

Árvores binárias Árvores binárias

Árvores binárias Árvores binárias

a) Solução de problemas de trás para frente c) Equivalente procedural de Recorrências

b) Analogia com a “Indução finita” d) Estrutura de um procedimento recursivo

Árvores binárias Árvores binárias

Sempre que uma chamada recursiva é executada, o 4 6.4=24

Chamadas recursivas podem ser expressas através

Árvores binárias Árvores binárias

Árvores binárias Árvores binárias

Estabilidade (manutenção da ordem relativa de D E

Árvores binárias Árvores binárias

Percursos recursivos Percurso recursivo em pré-ordem

Árvores binárias Árvores binárias

Percursos recursivos Percurso recursivo em ordem simétrica

Percursos recursivos Percurso recursivo em pós-ordem

Árvores binárias Árvores binárias

Exercício Árvores Binárias de Busca

Árvores binárias Árvores binárias

Árvores Binárias de Busca

ARI GEM TOU

CAN ESC LEA SAG VIR

Árvores Binárias de Busca

Árvores binárias Árvores binárias

Inserção uma ABB (com nó terminal).

Árvores binárias Árvores binárias

Propriedade fundamental de uma ABB: Exercício

In-ordem: 2 15 16 20 51 80 99 101 213

Exercício: Altura de uma ABB:

colocar as chaves A,B,C,D,E,F,G,H,I,J,K,L na Altura mínima: árvore completa.

Altura máxima: árvore degenerada. h = n 213

Altura média (Knuth 73): h ≈ 1,4 log2 n

Árvores binárias Árvores binárias

T(0) = 1; T(1) = 1; T(2) = 2; T(3) = 5; Calcular T(6) = número de distintas ABBs c/ 6

T(n) = Comb(2n, n)/(n+1). (Número de Catalão!!)