Universidade Federal da Paraba

Centro de Informtica
Departamento de Informtica

Estrutura de Dados
rvores

} Tiago Maritan
} tiago@ci.ufpb.br
1
 (
2
 Recursividade

3
Recursividade Motivao
} Sabemos que uma funo pode chamar outras funes
} Ex: func1() chamando a func2()

void func2(){
printf("Na funo 2");
}

void func1(){
printf("Na funo1");
printf("Vou chamar a funo2");
func2();
printf("No fim da funo1");
}

4
Recursividade - Motivao
} Hoje veremos que uma funo pode chamar ela mesma
} Ex: func1() chamando a si mesma

void func1(){
printf("No inicio da funo1");
func1();
printf("No fim da funo1);
}

} Mas isso util???

} No exemplo acima, no! Chama func1() infinitamente!

} E existe algum caso onde isso possa ser til?

} Existe sim! Nas funes recursivas! Estudaremos isso na aula de hoje!
5
Funo Recursiva
} Funo que chama a si mesma

} Deve conter duas partes:

} Caso recursivo no qual a funo chama a si mesma
} Caso no-recursivo estabelece uma condio de parada
da recurso

} Deve-se garantir que uma chamada recursiva atinja, em

algum momento, a condio de parada

6
Funo Recursiva
} Exemplo1: Funo que retorna a soma de inteiros de1 e n

//Retorna a soma dos inteiros entre 1 e n

int SomaAteN(int n){
if (n <= 1){
// Condio de parada
return n;
}
else{
// Caso recursivo
return (n + SomaAteN(n-1));
}
}

} Como funciona???
7
Funo Recursiva
} Exemplo1: Funo que retorna a soma de inteiros de1 e n
} Como funciona a chamada SomaAteN(4)?
SomaAteN(4)

4 + SomaAteN(3) 10

3 + SomaAteN(2) 6

2 + SomaAteN(1) 3

8
Funo Recursiva
} Exemplo 2: Funo fatorial

// Retorna o fatorial de um numero n

int fatorial (int n){
if (n <= 1){
// Condio de parada
return 1;
}
else{
// Caso recursivo
return (n * fatorial(n - 1));
}
}

9
Funo Recursiva
} Exemplo1: Funo que retorna a soma de inteiros de1 e n
} Como funciona a chamada fatorial(4)?
fatorial(4)

4 * fatorial(3) 24

3 * fatorial(2) 6

2 * fatorial(1) 2

10
Quando usar recursividade?
} Quando o problema tem uma estrutura recursiva
} Ou seja, uma instncia do problema contm uma instncia
menor do mesmo problema.
} Ex: fatorial(n) = n*fatorial(n-1)
}

} Menor instncia pode ser resolvida diretamente;

} Ex: fatorial(1) = 1;

} Quando a soluo iterativa do problema (usando while,

for, etc.) complexa.
} Ex: Torres de Hanoi;

11
Observaes sobre Recursividade
} uma tcnica elegante e, geralmente, quem a utiliza
demonstra experincia,

} Mas o seu uso possui um preo:

} Movimentao de dados na PILHA de chamadas de funes.
} Execuo, geralmente, mais lenta que as solues iterativas;.

} Portanto, deve se dar preferncia para solues iterativas

} Utilizar recursividade apenas nos casos apropriados
} Atentar para as caractersticas bsicas de um problema
recursivo

12
 )
13
 rvores

14
O que uma rvore?
} Em Cincia da Computao, uma rvore um modelo
abstrato de uma estrutura hierrquica
rvores
} Uma rvore consiste de um conjunto de ns com uma
relao pai-filho (hierrquica).

} Aplicaes:
} Sistemas de arquivos
} Organogramas
} Ambientes de Programao

16
 Terminologia de rvore
} Raiz: Primeiro n da rvore No contm um pai (A)
} N no-terminal: n com pelo menos um filho (A, B, C, F)
} N folha (ou n terminal) : n sem filhos (E, I, J, K, G, H,D)

} Grau de um n: nmero mximo de filhos de um n.

} Ascendentes de um n: pai, av, bisav etc.
} Profundidade de um n: nmero de ascendentes
} Altura de uma rvore: maior profundidade de qualquer n
} Descendente de um n: filho, neto, bisneto, etc.
Exemplo
} Sub-vore: rvore consistindo de um n e seus
descendentes

B C D

E F G H

I J K
subtree
 rvores Binrias

19
rvores Binrias
} um tipo de rvore, onde o grau
de cada n no mximo dois.

} Cada n tem no mximo 2 filhos.

} rvore Binria: Conjunto de ns

que ou vazio ou consiste de:
} Uma n raiz
} Duas rvores binrias disjuntas:
} Sub-rvores direita e
} Sub-rvore esquerda.

20
Implementao de rvores Binrias

21
Implementao de rvores Binrias
} Interface
} Criar uma rvore vazia;
} Verificar se a rvore est vazia ou no;
} Buscar um elemento na rvore;
} Inserir um n raiz;
} Inserir um filho direita de um n;
} Inserir um filho esquerda de um n;
} Esvaziar uma rvore;
} Exibir a rvore.

22
Implementao de rvores Binrias
/* Definio da Estrutura de Dados */

typedef struct no {
int conteudo; /* conteudo */
struct no *esq; /* ref. para filho da esquerda */
struct no *dir; /* ref. para filho da direita */
} tNo; /* tipo do n */

typedef tNo *tArvBin; /* tipo rvore binria */

23
Implementao de rvores Binrias
/* Definio das Operaes */

//Cria uma rvore vazia

void cria (tArvBin *T) {
*T = NULL;
}

//Verifica se a rvore est vazia

int vazia (tArvBin T) {
return (T == NULL);
}

24
Implementao de rvores Binrias
//Buscar um elemento na rvore
//Retorna o endereo se o elemento for
// encontrado, caso contrrio retorna NULL
tArvBin busca(tArvBin T, int dado) {
tArvBin achou;
if (T == NULL)
return NULL; // Arvore Vazia

if(T->conteudo == dado)
return T; //Elem. encontrado na raiz

achou = busca(T->esq, dado);

if (achou == NULL)
achou = busca(T->dir, dado);

return achou;
}
25
Implementao de rvores Binrias
// Insere um n raiz em uma rvore vazia
// Retorna 1 se a insero for com sucesso.
// Caso contrrio 0
int insereRaiz(tArvBin *T, int dado ) {
tNo *novoNo;
if (*T != NULL)
return (0); //Erro: rvore no est vazia

novoNo = malloc(sizeof(tNo));
if (novoNo == NULL) return 0; //Err: mem. Insuf.

novoNo->conteudo = dado;
novoNo->esq = NULL;
novoNo->dir = NULL;
*T = novoNo;
return 1;
}
26
Implementao de rvores Binrias
// Insere um filho direita de um dado n
// Retorna 1 se a insero for com sucesso,
// Caso contrrio 0
int insereDireita(tArvBin T, int vPai, int vFilho ) {
tNo *f, *p, *novoNo;
//Verifica se o elemento j no existe
f = busca(T, vFilho);
if (f != NULL) return 0; //Err: dado j existe

//Busca o pai e verifica se possui filho direito

p = busca(T, vPai);
if (p == NULL)
return 0; //Err: pai no encontrado
if (p->dir != NULL)
return 0; //Err: filho dir j existe
//continua...
27
Implementao de rvores Binrias

novoNo = malloc(sizeof(tNo));
if (novoNo == NULL)
return (0); //Err: mem. insuf.

novoNo->conteudo = vFilho;
novoNo->esq = NULL;
novoNo->dir = NULL;
p->dir = novoNo;
return 1;
}

28
Implementao de rvores Binrias
//Insere um filho esquerda de um dado n
//Retorna 1 se a insero for com sucesso,
// caso contrrio 0
int insereEsq(tArvBin T, int vPai, int vFilho ) {
tNo *f, *p, *novoNo;
//Verifica se o elemento j no existe
f = busca(T, vFilho);
if (f != NULL) return 0; //Err: dado j existe

//Busca o pai e verifica se possui filho direito

p = busca(T, vPai);
if (p == NULL)
return 0; //Err: pai no encontrado
if (p->esq != NULL)
return 0; //Err: filho esq j existe
//continua...
29
Implementao de rvores Binrias

novoNo = malloc(sizeof(tNo));
if (novoNo == NULL)
return (0); //Err: mem. insuf.

novoNo->conteudo = vFilho;
novoNo->esq = NULL;
novoNo->dir = NULL;
p->esq = novoNo;
return 1;
}

30
 Caminhamento em
rvores Binrias

31
Caminhamento em rvores Binrias
} Ao de percorrer (visitar) todos os ns de uma rvore
} Cada n visitado uma nica vez.

} Em geral, objetivo executar alguma operao nestes ns

} Ex: imprimir, consultar, alterar, etc.

} Contudo, em rvores no h nenhuma ordem linear

natural para se visitar os ns
} Podem-se definir vrias ordens de caminhamento.
} Por isso,
Listas, noso conhecidas
entanto, como estruturas
so estruturas no-lineares.
lineares porque existe uma
ordem linear natural para se visitar os ns.
Ex: do incio ao fim da lista.
32
Caminhamento em rvores Binrias
} Trs tipos de caminhamento em AVBin mais comuns so:
1. Caminhamento em ordem prefixa (pr-ordem);
2. Caminhamento em ordem infixa (in-ordem);
3. Caminhamento em ordem sufixa (ps-ordem).

B C

D E F

G H I

33
Caminhamento em rvores Binrias
} Esses mtodos de caminhamento em AVBin so
geralmente definidos de forma recursiva.

} Idia geral:
} Visitar a raiz, e
} Caminhar em suas sub-rvores esquerda e direita.

34
Caminhamento em Pr-ordem
} 1.Visite a raiz;
} 2. Caminhe na sub-rvore esquerda em pr-ordem;
} 3. Caminhe na sub-rvore direita em pr-ordem.

A
Sequncia de visitao dos
ns: ABDGCEHIF B C

D E F

G H I

35
Caminhamento em Pr-ordem
//Exibe o contedo de uma rvore em pr-ordem
void exibePreOrdem(tArvbin T) {
if (T == NULL)
return ;

printf(%d , T->conteudo);
if (T->esq != NULL)
exibePreOrdem(T->esq);

if (T->dir != NULL)
exibePreOrdem(T->dir);

36
Caminhamento em In-ordem
} 1. Caminhe na sub-rvore esquerda em in-ordem;
} 2.Visite a raiz.
} 3. Caminhe na sub-rvore direita em in-ordem;

A
Sequncia de visitao dos
ns: DGBAHEICF B C

D E F

G H I

37
Caminhamento em In-ordem
//Exibe o contedo de uma rvore em pr-ordem
void exibeInOrdem(tArvbin T) {
if (T == NULL)
return ;

if (T->esq != NULL)
exibeInOrdem(T->esq);

printf(%d , T->conteudo);

if (T->dir != NULL)
exibeInOrdem(T->dir);

38
Caminhamento em Ps-ordem
} 1. Caminhe na sub-rvore esquerda em ps-ordem;
} 2. Caminhe na sub-rvore direita em ps-ordem;
} 3.Visite a raiz.

A
Sequncia de visitao dos
ns: GDBHIEFCA B C

D E F

G H I

39
Caminhamento em Ps-ordem
//Exibe o contedo de uma rvore em pr-ordem
void exibePosOrdem(tArvbin T) {
if (T == NULL)
return ;

if (T->esq != NULL)
exibePosOrdem(T->esq);
if (T->dir != NULL)
exibePosOrdem(T->dir);

printf(%d , T->conteudo);

40
Caminhamento em rvores Binrias
} rvores binrias podem ser utilizadas para representar
expresses aritmticas.

} Neste mtodo de representao:

} Raiz da rvore contm o operador que deve ser aplicado;
} aos resultados das avaliaes das expresses aritmticas
representadas pelas sub-rvores esquerda e direita.

} Um n que representa um operador (binrio) possui duas

sub-rvores no-vazias, enquanto que um n que representa
um operando no possui sub-rvores (i.e., um n-folha).

41
Caminhamento em rvores Binrias
} Assim, a expresso A + B*C seria representada pela rvore:
+

A *

B C
} Enquanto que a expresso (A + B)*C seria representada como:
*

+ C

A B

42
rvores Ordenadas
} rvore ordenada: aquela na qual os filhos de cada n esto
ordenados.
} Assume-se ordenao da esquerda para a direita.

rvore Ordenada rvore No-Ordenada

43
 rvore Binria de Pesquisa

44
rvore Binria de Pesquisa
(ABP ou Arvore Binria de Busca)
} Arvores que so vazias ou que o n raiz contm uma chave e:
} Chaves da subrvore esquerda < chave da raiz.
} Chaves da subrvore direita > chave da raiz.
} Subrvores direita e esquerda so tambm ABP.

45
Implementao de ABPs
} Interface
} Criar uma rvore vazia;
} Verificar se a rvore est vazia ou no;
} Buscar um elemento na rvore;
} Inserir um n na rvore;
} Exibir a rvore;

46
Implementao de ABPs
/* Definio da Estrutura de Dados */

typedef struct no {
int info;
struct no *esq; /* n esquerdo */
struct no *dir; /* n direito */
} tNo; /* n da rvore */

typedef tNo *tAbp; /* ponteiro para a raiz da ABP */

47
Implementao de ABPs
/* Definio das Operaes */

//Cria uma rvore vazia

void cria (tAbp *T) {
*T = NULL;
}

//Verifica se a rvore est vazia

int vazia (tAbp T) {
return (T == NULL);
}

48
Implementao de ABPs
//Buscar um elemento na rvore
//Retorna o endereo se o elemento for encontrado,
//Caso contrrio retorna NULL
tAbp busca(tAbp T, int dado) {
tAbp achou;
if (T == NULL) return NULL; //Err: arv. Vazia;

if(T->info == dado)
return T;

if (T->info > dado)

return busca(T->esq, dado);
else
return busca(T->dir, dado);
}

49
Implementao de ABPs
//Exibe o contedo de uma rvore no formato in-ordem
//(preserva a ordenao)
void exibe (tAbp T) {
if (T != NULL) {
exibe(T->esq);
printf(%d , T->info);
exibe(T->dir);
}
}

50
Implementao de ABPs
//Insere um n em uma rvore ABP
//Retorna 1 se a insero for com sucesso.
//Caso contrrio retorna 0
int insere (tAbp T, int item) {
tNo *novoNo, *atual, *p;
novoNo = malloc(sizeof(tno));
if (novoNo == NULL) return 0;

novoNo->info = item;
novoNo->esq = NULL;
novoNo->dir = NULL;

if (T == NULL){ // Arvore vazia

T = novoNo;
return 1;
}
// continua... 51
Implementao de ABPs
atual = T;
while (atual != NULL) {
p = atual;
if (atual->info > item)
atual = atual->esq;
else
atual = atual->dir;
}
// Encontrou um n folha para inserir
if (p->info > item)
p->esq = novoNo;
else
p->dir = novoNo;

return 1;
}
52
Implementao de ABPs
// ou ... (insere em ABP no vazia)

if (item > (*T)->info){

ok = insere(&((*T)->dir), item);
}
else if (item < (*T )->info){
ok = insere(&((*T )-> esq), item);
}
return ok;

53
rvore Binria de Pesquisa Balanceada
(AVL)

54
ABPs Desbalanceadas
} Inseres e remoes sucessivas em uma ABP podem
torn-las desequilibradas ou desbalanceadas.
} Sub-rvores da esquerda e direita tem alturas muito diferentes;

} Desbalanceamento pode resultar em diferenas de

desempenho parar acessar aos ns da ABP.

55
ABPs Balanceada
} Uma ABP dita balanceada quando:
} Para qualquer n, as sub-rvores esquerda e direita possuem a
mesma altura (ou alturas similares).

56
rvore Binria de Pesquisa Balanceada
} O balanceamento de uma rvore binria pode ser:
} Esttico
} Dinmico (AVL ou rvores Rubro-negras)

} Balanceamento esttico: consiste em construir uma nova

verso da rvore, reorganizando-a.

} Balanceamento dinmico: a cada nova operao realizada

na ABP, so realizadas rotaes, para torn-la, novamente,
balanceada.
} AVL ou rvores Rubro-negras

57
rvores AVL
} O termo AVL foi definido em homenagem aos matemticos
russos Adelson-Velskii e Landis.

} rvores AVL so ABPs onde a diferena em altura entre as

sub-rvores esquerda e direita no mximo 1.

58
rvores AVL
} Uma rvore AVL mais eficiente nas suas operaes de
busca do que uma ABP degenerada (ou desbalanceada),
} O no comparaes diminui sensivelmente.

} Ex: rvore com 10.000 ns.

} rvore AVL: mdia de 14 comparaes em uma busca.
} rvore degenerada: mdia de 5.000 comparaes, numa busca;

59
Insero em rvores AVL
} O que pode acontecer quando um novo n inserido numa
rvore balanceada ?

} Seja uma rvore com subrvores E (esq) e D (dir), e supondo

que a insero deve ser feita na sub-rvore da esquerda.
Podemos distriguir 3 casos:
1. hE = hD: E e D ficam com alturas diferentes mas continuam
balanceadas.
2. hE < hD: E e D ficam com alturas iguais e balanceamento foi
melhorado.
3. hE > hD: E fica ainda maior e o balanceamento foi violado.

60
Insero AVL
} Ex: Suponha a rvore abaixo:

} Insero de 9 ou 11 no desbalanceia a rvore.

} Subrvore com raiz 10 passa a ter uma subrvore e
} Subrvore com raiz 8 vai ficar melhor balanceada !

} Insero dos ns 3, 5 ou 7 deixam a rvore desbalanceada

} Requerem que a rvore seja rebalanceada!
61
Insero AVL
} Fator de Balanceamento (FB) de um n: corresponde a
altura da subrvore direita do n menos a altura da
subrvore esquerda do n.

FB = hD(n) hE(n)

} Seja n um n qualquer da rvore:

} se FB(n) = 0, as duas sub-rvores tm a mesma altura;
} se FB(n) = -1, a sub-rvore esquerda mais alta em 1 nvel;
} se FB(n) = +1, a sub-rvore direita mais alta em 1 nvel;

62
Insero AVL
} Como manter ento uma rvore AVL aps as inseres?

} Soluo: a cada insero, rebalanceia a rvore.

} Fazer as correes necessrias para manter sempre a rvore
como uma AVL
} Qualquer n n deve ter |FB(n)| <= 1.

63
Insero AVL - Rebalanceamento
} Caso 1: Raiz de uma subrvore tem FB = 2 (ou -2) e um
filho com FB = 1 (-1), e os dois tem o mesmo sinal
Exemplo1: Exemplo2:

Soluo: Rotao simples sobre o n de FB=2 (-2).

Rotaes so feitas esquerda quando FB positivo e direita
quando FB negativo.
64
Insero AVL - Rebalanceamento
As subrvores T1, T2, T3 e T4
} Rotao esquerda podem ser vazias ou no.

Exemplo1:

10

8 15

4 9 12

65
Insero AVL - Rebalanceamento
} Rotao direita As subrvores T1, T2, T3 e T4
podem ser vazias ou no.

2 8

3 6 10

66
Insero AVL - Rebalanceamento
} Caso 2: Raiz de uma subrvore tem FB = 2 (ou -2) e um
filho com FB = 1 (-1), e os dois tem sinais opostos.

} Exemplo: FB(8) = -2, FB(4) = 1

Soluo: Duas rotaes:

1. Roda-se o n com FB=1 (-1) na direo apropriada
2. Depois roda-se o n que tinha FB=-2 (2) na direo oposta

67
Insero AVL - Rebalanceamento
} Exemplo: 1 Rotao - N 4 rotacionado esquerda

} Exemplo: 2 Rotao - N 8 rotacionado direita

68
Insero AVL - Rebalanceamento
} Dicas:
} FB positivo (+) a rotao para esquerda
} FB negativo (-) a rotao para direita

} Para identificar quando uma rotao simples ou dupla deve-

se observar os sinais do FB:
} Sinais iguais para pai e filho, a rotao simples
} Sinal diferentes para pai e filho, a rotao dupla

69
Remoo em rvore AVL
} A remoo mais complicada que a insero.

} Na insero, no mximo uma rotao (simples ou dupla)

servir para manter a rvore balanceada;

} Na remoo de um nico n, mais de uma rotao poder

ser necessria.

70
Remoo em rvore AVL
} 1) Remoo do n10

} Resultado: rvore ficar desbalanceada (FB(20) = 2).

} Soluo: Rotao simples esquerda.

71
Remoo em rvore AVL
} 2) Remoo do n 40

} Resultado: Arvore ficar desbalanceada (FB(30) = -2).

} Soluo: Rotao simples direita.

72
Remoo em rvore AVL
Remoo do n: 10

} Resultado: rvore desbalanceada, FB(20) = 2.

} Soluo: Duas rotaes (Rotao direita + rotao
esquerda)

73
Remoo em rvore AVL
Remoo do n: 40

} Resultado: rvore ficar desbalanceada, FB(30) = -2

} Soluo: Duas rotaes (rotao esquerda + rotao

direita)

74
Remoo em rvore AVL
} Existem situaes mais complexas.
} Balanceamento devido a retirada de um n de uma
subrvore, pode provocar um novo desequilbrio na rvore.

} Soluo: reaplicar o mtodo para a rvore desbalanceada

} Um novo desequilbrio pode ser provocado mais acima,
exigindo novo balanceamento.
} Repete-se o mesmo processo at que toda a rvore volte a
ser uma AVL.

75
Remoo em rvore AVL
} Exemplo: Remoo do n 65
} Passo 1: Rotao simples esquerda entre 70 e 80
Esta rvore AVL?

A rvore no AVL,
pois |FB(60)|>1.
76
Remoo em rvore AVL
} Exemplo: Remoo do n 65
} Passo 2: Reaplicar o mtodo para o 60.
} Rotao exigida a dupla (esquerda no 40 + direita no 60)

77
Remoo em rvore AVL
} Isso mostra porque a remoo mais complicada que a
insero.

} Enquanto que na insero, no mximo uma rotao (simples

ou dupla) servir para manter a rvore balanceada, na
remoo de um nico n, mais de uma rotao poder ser
necessria.

78
Concluses
} Balanceamento busca minimizar o nmero mdio de
comparaes necessrias para localizar qualquer dado.

} Operaes de insero e remoo tendem a tornar

as rvores desbalanceadas.
} H um custo extra de processamento.

} Esse custo compensado quando os dados armazenados

precisam ser recuperados muitas vezes.

79
Implementao de AVLs
} Interface
} Criar uma rvore vazia;
} Verificar se a rvore est vazia ou no;
} Buscar um elemento na rvore;
} Exibir a rvore;
} Inserir um n na rvore;

} Operaes cria(), vazia(), busca() e exibe()

so implementadas exatamente como nas ABPs

80
Implementao de AVLs
/* Definio da Estrutura de Dados */

typedef struct no {
int info;
int bal; /* fator de balanceamento */
struct no *esq;
struct no *dir;
} tNo;

typedef tNo *tAvl; /* ponteiro para raiz da AVL */

81
Implementao de AVLs
//Insere um n em uma rvore AVL
//Retorna 1 se a insero for com sucesso
//Retorna 0, caso contrrio.
int insere (tAvl *T, int item ) {
int ok;
if (*T == NULL){ // Arvore vazia
*T = malloc(sizeof(tNo));
if (*T == NULL) return 0; //Err: mem

(*T )->info = item;

(*T )->bal = 0;
(*T )-> esq = NULL;
(*T ) dir = NULL;
return 1;
}
// continua

82
Implementao de AVLs
if ((*T )->info > item) {
//recursividade esquerda
ok = insere(&((*T )->esq), item);
if (ok != 0){
//prxima raiz a se verificar o FB
switch ((*T)->bal) {
case 1: (*T)->bal = 0;
ok = 0;
break;
case 0: (*T)->bal = -1;
break;
case -1: caso1(&(*T)); //FB(p) = -2
ok = 0;
break;
}
}
}// continua
83
Implementao de AVLs
else if ((*T )->info < item) {
//recursividade direita
ok = insere(&((*T )->dir), item);
if (ok){
switch ((*T)-> bal) {
//prxima raiz a se verificar o FB
case -1: (*T)->bal = 0;
ok = 0; break;
case 0: (*T)->bal = 1; break;
case 1: caso2(&(*T)); //FB(p) = 2
ok = 0; //no propaga mais
break;
}
}
} else
ok = 0;
return ok;
} //fim do insere
84
Implementao de AVLs
//Rotina auxiliar de insere
//Item foi inserido esquerda de T e causa
//desbalanceamento FB(T) = -2
void caso1 (tAvl *T) {
tAvl u;
u = (*T )->esq;
if (u->bal == -1)
rot_dir(&(*T)); // sinais iguais e negativo
else
rot_esq_dir(&(*T)); // sinais diferentes

(*T ) bal = 0;
}

85
Implementao de AVLs
//Rotina auxiliar de insere
//Item foi inserido direita de T e causa
//desbalanceamento FB(T) = 2
void caso2 (tAvl *T) {
tAvl u;
u = (*T )->dir;
if (u->bal == 1)
rot_esq(&(*T)); // sinais iguais e positivo
else
rot_dir_esq (&(*T)); // sinais diferentes

(*T ) bal = 0;
}

86
Implementao de AVLs
//Rotina responsvel pela rotao para a direita
void rot_dir (tAvl *T) {
tAvl u;
u = (*T )->esq;
(*T )->esq = u->dir;
u->dir = *T;
(*T )->bal = 0;
*T = u;
}

87
Implementao de AVLs
//Rotina responsvel pela rotao para a esquerda
void rot_esq (tAvl *T) {
tAvl u;
u = (*T )->dir;
(*T )->dir = u->esq;
u->esq = *T;
(*T ) bal = 0;
*T = u;
}

88
Implementao de AVLs
//Rotina que rotaciona esquerda e depois direita
void rot_esq_dir (tAvl *T) {
tAvl u,v;
u = (*T )->esq;
v = u->dir;
u->dir = v->esq;
v->esq = u;
(*T )->esq = v->dir;
v->dir = *T;
if (v->bal == -1)
(*T )->bal = 1;
else
(*T )->bal = 0;
if (v->bal == 1)
u->bal = -1;
else u->bal = 0;
*T = v;
89
}
Implementao de AVLs
//Rotina que rotaciona a direita e depois a esquerda
void rot_dir_esq (tAvl *T) {
tAvl u,v;
u = (*T )->dir;
v = u->esq;
u->esq = v->dir;
v->dir = u;
(*T )->dir = v->esq;
v->esq = *T;
if (v->bal == 1)
(*T )->bal = -1;
else (*T )->bal = 0;
if (v->bal == -1)
u->bal = 1;
else u->bal = 0;
*T = v;
}
90
 Universidade Federal da Paraba
Centro de Informtica
Departamento de Informtica

Estrutura de Dados
rvores

} Tiago Maritan
} tiago@ci.ufpb.br
91