RVORES BINRIAS

Definio
rvore Binria T um conjunto finito de
elementos denominados ns ou vrtices, tal que:
T = 0 e a rvore dita vazia ou
Existe um n r, chamado raiz de T, e os ns restantes
podem ser divididos em dois subconjuntos disjuntos, Tre e
Trd, que so as sub-rvores esquerda e direita de r,
respectivamente e as quais, por sua vez, tambm so
rvores binrias.

Vantagens
Possuem um nmero constante de sub-rvores
em cada n
Limitao do nmero de ponteiros usados

Algoritmos eficientes para o tratamento

A forma de armazenar os ns surge naturalmente
de sua definio:
Ponteiro para o n raiz (como nas listas lineares)
Ponteiros para os filhos: esq e dir
Necessita de 2n+1 ponteiros para representar n ns.

Visualizao da rvore Binria usando

ponteiros
raiz
esq

A
dir

C
E

Definio da Estrutura de Dados

rvore Binria usando ponteiros
type
Ponteiro
TipoItem

= ^TipoNo;
= record
chave: TipoChave;
{outros componentes...}
end;
TipoNo
= record
Reg: TipoItem;
esq, dir: Ponteiro;
end;
TipoArvoreBin = Ponteiro;

Operaes Bsicas da rvore Binria

1. Inicializa(Arvore): define um arvore vazia
2. CriarRaiz(Arvore): retorna o n raiz da rvore
que foi criado em Arvore
3. Vazia(Arvore): Funo que retorna TRUE se a
rvore est vazia e FALSE do contrrio;
4. InserirFilhoaDireita(Arvore,pai,item): Insere o
elemento item na rvore direita do n pai se ele
no possui um filho direita;
5. InserirFilhoaEsquerda(Arvore,pai,item): Insere o
elemento item na rvore esquerda do n pai;

Operaes Bsicas da rvore Binria

6. Busca(Arvore, item,pont): retorna o ponteiro
pont para o n item em Arvore; se item no
existe retorna nil
7. PercursoPosOrdem(Arvore): percorre em psordem;
8. PercursoPreOrdem(Arvore): percorre em prordem;
9. PercursoEmOrdem(Arvore): percorre ns em
ordem;
10. Esvaziar(Arvore): libera todo o espao de
memria alocado pela rvore, tornando-a vazia
11. Remover(Arvore, item, flag): remover o n item
de Arvore; flag = FALSE se n no existe

Operaes sobre rvores Binrias

usando Ponteiros
procedure Inicializa(var Arvore: TipoArvoreBin);
Begin
Arvore := nil;
End;
procedure CriarRaiz(var Arvore: TipoArvoreBin);
var no: TipoArvoreBin;
begin
new(n);
no^.esq := nil;
no^.dir := nil;
Arvore := no;
end;
function Vazia(var Arvore: TipoArvoreBin): boolean;
Begin
Vazia := Arvore = nil;
End;

Operaes sobre rvores Binrias

usando Ponteiros
procedure InserirFilhoaDireita(var Arvore: TipoArvoreBin;
pai: TipoItem; item: TipoItem);
var p, no: TipoArvoreBin;
begin
Busca(Arvore, pai, p);
if (p<>nil) then
if (p^.dir <> nil) then
writeln("item possui subrvore direita")
else begin
new(no);
no^.esq := nil;
no^.dir := nil;
no^.Reg.Chave := item.Chave;
p^.dir := no;
end;
end;

Operaes sobre rvores Binrias

usando Ponteiros
procedure InserirFilhoaEsquerda(var Arvore: TipoArvoreBin;
pai: TipoItem; item: TipoItem);
var p, no: TipoArvoreBin;
begin
Busca(Arvore, pai, p);
if (p<>nil) then
if (p^.esq <> nil) then
writeln("item possui subrvore esquerda")
else begin
new(no);
no^.esq := nil;
no^.dir := nil;
no^.Reg.Chave := item.Chave;
p^.esq := no;
end;
end;

Operaes sobre rvores Binrias

usando Ponteiros
procedure Busca(VAR Arvore: TipoArvoreBin; item: TipoItem;
pont: Ponteiro);
VAR
p: TipoArvoreBin;
achou : boolean;
procedure Busca_Binaria (p: TipoArvoreBin; item: TipoItem;
VAR pont: TipoArvoreBin; VAR achou: boolean);
BEGIN
( cdigo a seguir )
END;
BEGIN {procedure busca}
achou := FALSE;
pont := nil;
Busca_Binaria(Arvore,item,pont,achou);
END;

Procedure Busca_Binaria() verso 1

procedure Busca_Binaria(p: TipoArvoreBin; item: TipoItem;
VAR pont: Ponteiro; VAR achou: boolean);
BEGIN
IF (p<>nil) THEN BEGIN
IF (p^.Reg.Chave = item) THEN BEGIN
achou := TRUE;
pont := p;
END
ELSE
IF (NOT achou) THEN
Busca_Binaria(p^.esq,item,pont)
ELSE IF (NOT achou) THEN
Busca_Binaria(p^.dir,item,pont);
END;
END;

Melhorando a Busca... E se os ns da
rvore estivessem ordenados?
raiz
esq

C
dir

H
E

Essa a famosa rvore Binria de Busca:

- Ns da sub-rvore da esquerda so menores do que a raiz
- Ns da sub-rvore da direita so maiores do que a raiz

Melhorando a Busca... E se os ns da
rvore estivessem ordenados?
Procedure Busca_Binaria(p: TipoArvoreBin; item: TipoItem;
VAR pont: Ponteiro; VAR achou: boolean);
BEGIN
achou := FALSE;
while (NOT achou) AND (NOT Vazia(p)) do begin
if (p^.Item.Chave = x) then achou:= TRUE
else if p^.Item.Chave < x then
p := p^.dir
else p := p^.esq;
end;
Busca_Binaria:=p;
END;

Percursos em rvores Binrias

A busca nada mais do que um percurso em
uma rvore
O percurso em uma rvore visitando cada n
uma nica vez gera uma seqncia linear de ns
Assim, passa a ter sentido falar em sucessor e
predecessor de um n segundo um determinado
percurso
H trs maneiras recursivas de se percorrer
rvores binrias:
Percurso em pr-ordem
Percurso em ps-ordem
Percurso em ordem

Percurso em Pr-Ordem (RED)

Algoritmo bsico:
1. Se rvore vazia fim
2. visitar o n raiz
3. percorrer em pr-ordem a sub-rvore esquerda
4. percorrer em pr-ordem a sub-rvore direita

ABDCEGFHI

Percurso em Em Ordem

Algoritmo bsico:
1. Se rvore vazia fim
2. percorrer em ordem a sub-rvore esquerda
3. visitar o n raiz
4. percorrer em ordem a sub-rvore direita

DBAEGCHFI

Percurso em Ps-Ordem

Algoritmo bsico:
1. Se rvore vazia fim
2. percorrer em ordem a sub-rvore esquerda
3. percorrer em ordem a sub-rvore direita
4. visitar o n raiz

DBGEHIFCA

Operaes sobre rvores Binrias

usando Ponteiros
procedure PreOrdem(var Arvore: TipoArvoreBin);
/* versao recursiva do algoritmo */
var p: TipoArvoreBin;
begin
if (Arvore <> nil) then begin
Processa(p); {por. ex. imprimir a chave}
PreOrdem(p^.esq);
PreOrdem(p^.dir);
end;
end;

Operaes sobre rvores Binrias

usando Ponteiros
procedure EmOrdem(var Arvore: TipoArvoreBin);
/* versao recursiva do algoritmo */
var p: TipoArvoreBin;
begin
if (Arvore <> nil) then begin
EmOrdem(p^.esq);
Processa(p); {por. ex. imprimir a chave}
EmOrdem(p^.dir);
end;
end;

Operaes sobre rvores Binrias

usando Ponteiros
procedure PosOrdem(var Arvore: TipoArvoreBin);
/* versao recursiva do algoritmo */
var p: TipoArvoreBin;
begin
if (Arvore <> nil) then begin
PosOrdem(p^.esq);
PosOrdem(p^.dir);
Processa(p); {por. ex. imprimir a chave}
end;
end;

Implementaes das Operaes

Diversas operaes se utilizam desses algoritmos
de percurso em rvore durante sua execuo:
Insero, Remoo, nvel, etc...
Basta alterar a funo Processa(p) nos algoritmos
anteriores...

Exemplo:
Operao Esvaziar: esvaziar toda a rvore
Operao Nvel: Implementar uma funo para retornar o
nvel de um elemento na rvore
Observaes:
Supe-se que todas as chaves sejam diferentes

Operaes sobre rvores Binrias

usando Ponteiros
procedure Esvaziar(VAR p: TipoArvoreBin);
/* Basta trocar o procedimento Processa(P) na busca em
Ordem por dispose(P)*/
BEGIN
IF (NOT Vazia(p)) THEN
Esvaziar(p^.esq);
Esvaziar(p^.dir);
dispose(p);
END;
p := nil;
END;

Operaes sobre rvores Binrias

usando Ponteiros
function Nivel(var Arvore: TipoArvoreBin; item: TipoItem):
integer
var n: integer;
ok: boolean;
procedure Percorrer (ptr: TipoArvoreBin; var n: integer;
item: TipoItem; var achou:boolean);
begin
ok := FALSE;
n := 0;
Percorrer(Arvore,n,item,ok);
Nivel := n;
end;

Procedure Percorrer
procedure Percorrer (ptr: TipoArvoreBin; var n: integer;
item: TipoItem; var achou:boolean);
begin
if ptr = nil then achou := FALSE
else begin
n:=n+1;
if (ptr^.Reg.Chave = item.Chave) then achou := TRUE
else begin
Percorrer (ptr^.esq, n, item, achou);
if (NOT achou) then
Percorrer (ptr^.dir, n, item, achou);
if (NOT achou) then n:=n-1;
end;
end;
end;

FIM