rvores

Nesta aula veremos

conceitos e definies
sobre rvores
Diferentemente das
estruturas de pilhas, filas e
listas que so lineares, uma
rvore uma estrutura de
dados no linear
Algoritmos e
Estruturas de Dados I
Jos Augusto Baranauskas
Departamento de Fsica e Matemtica FFCLRP-USP

augusto@usp.br
http://dfm.ffclrp.usp.br/~augusto

Introduo
Como visto, listas podem ser convenientemente definidas
da seguinte forma: Uma lista do tipo T
Uma lista (estrutura) vazia ou
Uma concatenao (cadeia) de um elemento do tipo T com uma
lista cujo tipo bsico tambm seja T

Nota-se que a recurso utilizada como ferramenta de

definio
Um rvore uma estrutura sofisticada cuja definio por
meio de recurso elegante e eficaz
Uma rvore, com tipo T, pode ser definida recursivamente
da seguinte forma:
Uma rvore (estrutura) vazia ou
Um n do tipo T associado a um nmero finito de estruturas
disjuntas de rvore do mesmo tipo T, denominadas subrvores

Introduo
Observando a similaridade das definies
evidente que uma lista possa ser
considerada como uma rvore na qual
cada n tem, no mximo, uma nica
subrvore
Por este motivo, uma lista tambm
denominada rvore degenerada

Definio
Uma rvore um conjunto finito de um ou mais
ns (ou vrtices) tais que
Existe um n especial, denominado raiz
Os demais ns encontram-se desdobrados em n 0
conjuntos disjuntos T1, ..., Tn sendo que cada conjunto
se constitui numa rvore
T1, ..., Tn so denominadas subrvores da raiz

Utilizaremos grafos para representar rvores

Todavia, existem outras representaes
equivalentes para rvores: conjuntos aninhados
(diagrama de incluso), parnteses aninhados,
paragrafao (indentation)

Representaes
Uma rvore um grafo sem ciclos
A

Representaes
Conjuntos aninhados

Grafo

A
B
B
E
K

C
F

D
H
L

E
J

C
F

I
J

Representaes
Parnteses aninhados

Grafo

( (A (B (E (K) (F)) C (G)

D (H (L) (I) (J))))
A
B
E
K

C
F

D
H
L

Representaes
Grafo

A
B
E
K

C
F

D
H
L

Paragrafao
A
B
E
K
F
C
G
D
H
L
I
J

Representaes
Grafo

A
B
E
K

C
F

D
H
L

Paragrafao
A
..B
....E
......K
....F
..C
....G
..D
....H
......L
....I
....J

Ns (Vrtices)
Esta rvore possui 12 ns (ou vrtices)
ns

Arestas (Arcos)
Uma aresta (arco) liga um n a outro
arestas

Raiz
Normalmente as rvores so desenhadas
de forma invertida, com a raiz em cima

raiz

Subrvores
No exemplo, o n A possui trs
subrvores (ramos) cujas razes so B, C
eD
A

Subrvores
No exemplo, o n B possui duas
subrvores (ramos) cujas razes so E e F
A

Folha
Um n sem descendentes (sem filhos ou sem
sucessores) denominado terminal ou folha
A

No-Folha
Um n com descendentes (com filhos ou com
sucessores) denominado no-terminal ou nofolha ou interior
A

Floresta
Uma floresta um conjunto de zero ou
mais rvores
No exemplo, temos 3 rvores que
compem uma floresta
B

Grau de um N
O nmero de descendentes (imediatos) de um n
denominado grau deste n
N
Grau
A
B

C
D

F
G

H
I
J

K
L

Grau de um N
O nmero de descendentes (imediatos) de um n
denominado grau deste n
N
Portanto, o grau de uma folha zero
A
B
(e vice-versa)
A

Grau
3
2

Grau de uma rvore

O grau mximo atingido pelos ns de uma rvore
denominado grau desta rvore
No exemplo, o grau da rvore 3
A

rvore Completa
Uma rvore de grau d uma rvore completa (cheia) se
Todos os ns tem exatamente d filhos, exceto as folhas e
Todas as folhas esto na mesma altura

No exemplo, a rvore de grau d=3 completa

A

Pai
As razes das subrvores de um n X so os filhos de X;
X o pai dos filhos
N Pai
Ns Filhos
A

B, C, D

E, F

H, I, J

Irmo
Os filhos (descendentes) de um mesmo n pai
(antecessor) so denominados irmos
A
Irmos

B, C, D

E, F
H, I, J

Av & Demais Parentes

Podemos estender essa terminologia para av, bisav, e
demais parentes
A

Ns

Av

E,F,G,H,I,J

Ns

Bisav

K, L

Caminho
Uma seqncia de ns distintos v1, v2, ..., vk tal
que sempre existe a relao
vi filho de vi+1 ou vi pai de vi+1, 1 i < k

denominada um caminho entre v1 e vk

Diz-se que v1 alcana vk ou que vk alcanado
por v1
Um caminho de k vrtices v1, v2, ..., vk formado
pela seqncia de k-1 pares de ns (v1,v2),
(v2,v3), ..., (vk-2,vk-1), (vk-1,vk)
k-1 o comprimento do caminho
Cada par (vi, vi+1) uma aresta ou arco, 1 i < k

Caminho
No Exemplo:
A, D, H, L um caminho entre A e L, formando pela seqncia de arestas
(A,D), (D,H), (H,L)
O comprimento do caminho entre A e L 3
A

Antecessores
Os antecessores (antepassados) de um n so todos
os ns no caminho entre a raiz e o respectivo n
No exemplo, os antecessores de L so A, D e H
A

Nvel
O nvel (ou profundidade) de um n definido
admitindo-se que a raiz est no nvel zero (nvel um)
Estando um n no nvel i, seus filhos estaro no nvel i+1
No existe um padro quanto ao nvel adotado para a
raiz, que determina o nvel dos demais ns
Assim, a raiz pode ser admitida como estando
No nvel zero
Alternativamente, no nvel um

No restante desta apresentao, vamos adotar a raiz no

nvel zero
A adequao das frmulas e algoritmos caso a raiz seja
considerada no nvel um deixada como exerccio

Nvel
No exemplo, os ns:
B, C e D esto no nvel 1
K e L esto no nvel 3
0

Altura de um N
A altura de um n o nmero de arestas no maior
caminho desde o n at um de seus descendentes
Portanto, as folhas tm altura zero
No exemplo, os ns:
A

K, F, G, L, I, J tm altura 0
E, C e H tm altura 1
B e D tm altura 2
A tem altura 3
E

Altura de uma rvore

A altura (ou profundidade) de uma rvore o
nvel mximo entre todos os ns da rvore ou,
equivalentemente, a altura da raiz
A
No exemplo, a rvore
possui altura 3
B

Nmero Mximo de Ns
O nmero mximo de ns n(h,d) em uma
rvore de altura h atingido quando todos
os ns possurem d subrvores, exceto os
de nvel h, que no possuem subrvores
Para uma rvore de grau d

Nvel 0 contm d0 (um) n (raiz)

Nvel 1 contm d1 descendentes da raiz
Nvel 2 contm d2 descendentes
...
Nvel i contm di descendentes

Nmero Mximo de Ns
Assumindo d=3

Nvel 0: 1 n (raiz)
Nvel 1: 3 ns
Nvel 2: 32 = 9 ns
Nvel 3: 33 = 27 ns

n(3,3)= 1 + 3 + 9 + 27 = 40 ns

Nmero Mximo de Ns
Portanto, o nmero mximo de ns
n=n(h,d) soma do nmero de ns em
cada nvel, ou seja:
h

n = n(h, d ) = d = d + d + d + L + d
i

i =0

h +1

1
, d >1
d =

d 1
i =0
h

rvores (Perfeitamente)
Balanceadas
Uma rvore balanceada se, para cada
n, a altura de suas subrvores diferem,
no mximo, de uma unidade
Uma rvore perfeitamente balanceada
se, para cada n, os nmeros de ns em
suas subrvores diferem, no mximo, de
uma unidade
Todas as rvores perfeitamente
balanceadas tambm so rvores
balanceadas

rvores Perfeitamente Balanceadas

de Grau 2

n=5

n=1

n=2

n=3

n=4

n=6

n=7

rvores Balanceadas de Grau 2

rvore Orientada
Uma rvore orientada (ordenada) uma rvore na qual os filhos de
cada n so orientados (ordenados)
A orientao da esquerda para a direita
As duas rvores orientadas seguintes so distintas
A
B

Implementao de rvores
rvores podem ser implementadas
utilizando listas encadeadas
Cada n possui um campo de informao e
uma srie de campos de ligao, de acordo
como nmero de filhos daquele n
Dados

Campo de ligao
Campo de ligao
para a segunda subrvore para a prxima subrvore

4
Campo de ligao
para a primeira subrvore

Campo de ligao
para a prxima subrvore

Implementao de rvores
Entretanto, mais simples o caso em que
cada n tem um nmero mximo de filhos d
pr-estabelecido

...
Dados

Campo de ligao
para a primeira
subrvore

Campo de ligao
para a segunda
subrvore

Campo de ligao
para a d-sima
subrvore

Implementao de rvores
Por exemplo, a rvore
ternria seguinte
(d=3)...

... pode ser

implementada como
root
A

A
B

D
C

B
E

J
E

L
K

rvores Binrias (AB)

rvores binrias so rvores orientadas de grau 2
Uma rvore binria uma estrutura que ou vazia ou
possui 3 componentes:
Uma raiz
Uma subrvore esquerda
Uma subrvore direita

As subrvores devem ser rvores binrias

A
Sub-rvore
esquerda

C
D

Sub-rvore
direita

rvores Binrias
Podemos, por exemplo,
representar uma
expresso aritmtica (com
operadores binrios) por
meio de uma AB, na qual
cada operador um n da
rvore e seus dois
operandos representados
como subrvores
A rvore ao lado
representa a expresso
(a+b/c)*(d-e*f)

*
+

a
b

d
c

*
e

rvores Binrias
As duas AB seguintes so distintas
(i) a primeira tem subrvore direita vazia
(ii) a segunda tem subrvore esquerda vazia

B
(i)

(ii)

rvores Binrias
Exemplos de AB
(i) assimtrica esquerda (degenerada)
(ii) completa
A

A
B

B
D

(i)

C
E

(ii)

rvores Binrias
O nmero de mximo de ns em uma
rvore binria de altura h dado por:
h

n = n(h,2) = 2i = 2 h +1 1
i =0

Portanto, n elementos podem ser

organizados em uma rvore binria de
altura mnima log2 n

h = log 2 (n + 1) 1

rvores Binrias de Altura Mnima

2000

1500
1000
500
0
0

10

7
6
5
4
3
2
1
97

91

85

79

73

67

61

55

49

43

37

31

25

19

13

0
7

h
0
1
1
2
2
2
2
3
3
3
3
3
3
3
3
4

2500

n
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

n
1
3
7
15
31
63
127
255
511
1023
2047

h
0
1
2
3
4
5
6
7
8
9
10

rvores Binrias de Altura Mnima

160
140
120
100
80
60
40
20
1.E+42

1.E+39

1.E+36

1.E+33

1.E+30

1.E+27

1.E+24

1.E+21

1.E+18

1.E+15

1.E+12

1.E+09

1.E+06

0
1.E+03

h
9
19
29
39
49
59
69
79
89
99
109
119
129
139

n
1.E+03
1.E+06
1.E+09
1.E+12
1.E+15
1.E+18
1.E+21
1.E+24
1.E+27
1.E+30
1.E+33
1.E+36
1.E+39
1.E+42

Percurso em AB
Seja uma AB em que R denota sua raiz, E e D
denotam as subrvores esquerda e direita,
respectivamente
Os ns de uma AB podem ser visitados de trs
formas (varredura da rvore):
Pr-ordem (pre-order): R, E, D

visitar a raiz antes das subrvores

Em-ordem (in-order): E, R, D
Ps-ordem (post-order): E, D, R
visitar a raiz aps visitar as subrvores

Percurso em AB
Pr-ordem: A, B, D, H, E, C, F, I, G
A

Percurso em AB
Em-ordem: H, D, B, E, A, I, F, C, G
A

Percurso em AB
Ps-ordem: H, D, E, B, I, F, G, C, A
A

Percurso em AB
Pr-ordem

*+a/bcd*ef

Em-ordem

a+b/c*de*f

Ps-Ordem
abc/+def**

a
b

d
c

*
e

Implementao de rvores Binrias

natural a implementao de rvores por
meio de ponteiros
Como toda rvore possui uma raiz (root),
uma rvore vazia pode ser representada
por um ponteiro aterrado (NULL em C++)
Cada n em uma rvore binria possui um
campo de dados, um ponteiro para a
subrvore esquerda e um ponteiro para a
sub-rvore direita

Implementao de rvores Binrias

Campo de dados
(Entry)

Campo de ligao
para subrvore esquerda
(LeftNode)
Esquematicamente:

N
(TreeNode)
Campo de ligao
para subrvore direita
(RightNode)

Dados

Ligao
para subrvore esquerda

Ligao
para subrvore direita

Questo
Utilize estas idias
para escrever uma
declarao de tipo que
poderia implementar
uma rvore binria
para armazenar valores
inteiros.
Voc tem 5 minutos
para escrever a declarao

Uma Soluo
class BinaryTree
{ public:
BinaryTree();
~BinaryTree();
void Insert(int x);
void Delete(int x);
bool Search(int x);

private:
// declarao de tipos
struct TreeNode
{ int Entry;
// tipo de dado colocado na rvore
TreeNode *LeftNode, *RightNode; // subrvores
};
typedef TreeNode *TreePointer;
// declarao de campos
TreePointer root;
};

Uma Soluo
class BinaryTree
{ public:
BinaryTree();
~BinaryTree();
Observe que o tipo
void Insert(int x);
void Delete(int x);
TreeEntry nesse caso
bool Search(int x);
um inteiro

private:
// declarao de tipos
struct TreeNode
{ int Entry;
// tipo de dado colocado na rvore
TreeNode *LeftNode, *RightNode; // subrvores
};
typedef TreeNode *TreePointer;
// declarao de campos
TreePointer root;
};

Implementao de rvores Binrias

root
A

Implementao de rvores Binrias

root

*
+
/

a
b

d
c

*
e

f
a

Operaes Bsicas
Com a definio dada j possvel implementar
alguns mtodos para AB que tambm se aplicam
para ABB (vista a seguir)
Como os algoritmos em geral so recursivos,
sero declarados dois mtodos de mesmo nome
O mtodo pblico que faz uma chamada ao mtodo
privado de mesmo nome, passando os parmetros
necessrios para o mtodo privado recursivo
(normalmente a raiz; mas outros parmetros tambm
podem ser passados)
O mtodo privado que efetivamente implementa o
algoritmo recursivo

Nmero de Ns
int BinaryTree::Nodes();
pr-condio: rvore binria j tenha sido criada
ps-condio: retorna o nmero de ns existentes na
rvore

Uma idia para encontrar o nmero de ns

utilizar recurso:
Caso base: uma rvore vazia possui zero ns
Caso recursivo: uma rvore que contm um n possui
1 (o prprio n) somado ao nmero de ns na sua
subrvore esquerda somado ao nmero de ns na sua
subrvore direita

Nmero de Ns
int BinaryTree::Nodes() // mtodo pblico
{ return Nodes(root);
}
//---------------------------------------------------------------------------int BinaryTree::Nodes(TreePointer &t) // mtodo privado
{
if(t == NULL)
return 0;
else
return 1 + Nodes(t->LeftNode) + Nodes(t->RightNode);
}

Nmero de Folhas
int BinaryTree::Leaves();
pr-condio: rvore binria j tenha sido criada
ps-condio: retorna o nmero de folhas existentes
na rvore

Novamente, o uso de recurso permite encontrar

o nmero de folhas:
Caso base 1: uma rvore vazia possui zero folhas
Caso base 2: um n cujas subrvores esquerda e
direita so ambas vazias uma folha
Caso recursivo: o nmero de folhas de uma rvore que
contm um n (no nulo) determinado pelo nmero
de folhas da subrvore esquerda deste n somado ao
nmero de folhas da subrvore direita deste n

Nmero de Folhas
int BinaryTree::Leaves()
{ return Leaves(root);
}
//------------------------------------------------------------------------int BinaryTree::Leaves(TreePointer &t)
{ if(t == NULL)
return 0;
else
if(t->LeftNode == NULL && t->RightNode == NULL)
return 1;
else
return Leaves(t->LeftNode) + Leaves(t->RightNode);
}

Altura
int BinaryTree::Height();
pr-condio: rvore binria j tenha sido criada
ps-condio: retorna a altura da rvore

A definio de altura de uma rvore nos leva ao

seguintes casos
Caso base: a altura de uma rvore vazia -1 (por
definio a altura das folhas 0; portanto parece
natural adotar -1 como a altura de uma rvore vazia)
Caso recursivo: a altura de uma rvore que contm um
n (no nulo) determinada como sendo a maior
altura entre as subrvores esquerda e direita deste n
adicionado a um (uma unidade a mais de altura devido
ao prprio n)

Altura
int BinaryTree::Height()
{ return Height(root);
}
//-------------------------------------------------------------------------int BinaryTree::Height(TreePointer &t)
{ if(t == NULL)
return -1;
else
{ int L,R;
L = Height(t->LeftNode);
R = Height(t->RightNode);
if(L>R) return L+1; else return R+1;
}
}

Percurso em Pr-Ordem
Para percorrer uma AB em pr-ordem, assumese que existe um procedimento (ou mtodo)
denominado
void process(TreeEntry x)

que efetua algum tipo de processamento com o

valor x passado como parmetro, lembrando que
TreeEntry o tipo de dado que colocado na AB
Os demais percursos so similares e sua
implementao fica como exerccio

Percurso em Pr-Ordem
void BinaryTree::PreOrder()
{ PreOrder(root);
}
//-------------------------------------------------------------------------void BinaryTree::PreOrder(TreePointer &t)
{
Em situaes
if(t != NULL)
mais simples,
{ process(t->Entry);
process pode ser
PreOrder(t->LeftNode);
substitudo por
um comando de
PreOrder(t->RightNode);
escrita
}
}

Percurso em Pr-Ordem
void BinaryTree::PreOrder()
{ PreOrder(root);
}
//-------------------------------------------------------------------------void BinaryTree::PreOrder(TreePointer &t)
{
Em situaes
if(t != NULL)
mais simples,
{ cout << t->Entry << endl;
process pode ser
PreOrder(t->LeftNode);
substitudo por
um comando de
PreOrder(t->RightNode);
escrita
}
}

Impresso
A impresso de uma rvore binria pode
ser efetuada utilizando algum dos
percursos (pr-, in- ou ps-ordem) ou
qualquer outra estratgia que for mais
adequada
A implementao seguinte imprime com
deslocamentos (espaos) uma AB

Impresso
void BinaryTree::Print()
{ BinaryTree::Print(root,0);
}
//-------------------------------------------------------------------------void BinarySearchTree::Print(TreePointer &t, int s)
{ int i;
if(t != NULL)
{ Print(t->RightNode, s+3);
for(i=1; i<=s; i++)
cout << ;
// espaos
cout << setw(6) << t->Entry << endl;
Print(t->LeftNode, s+3);
}
}

Consideraes Finais
Nesta apresentao foram vistos vrios conceitos
sobre rvores e rvores binrias, incluindo alguns
algoritmos mais elementares
Entretanto, imagine o processo de busca de
informao em uma rvore (binria ou no)
Se as chaves no esto em uma ordem prestabelecida, toda a estrutura precisa ser percorrida
para encontrar uma determinada chave (no pior caso),
o que no seria eficiente

Veremos na prxima apresentao uma forma de

melhorar o tempo de busca, utilizando rvores
Binrias de Busca

Slides baseados em:

Horowitz, E. & Sahni, S.;
Fundamentos de Estruturas de Dados,
Editora Campus, 1984.
Wirth, N.; Algoritmos e Estruturas de Dados,
Prentice/Hall do Brasil, 1989.
Material elaborado por
Jos Augusto Baranauskas
Elaborao inicial 2004; Reviso atual 2007