Você está na página 1de 49

rvores de Busca Balanceadas

Fernando Vanini IC - UNICAMP

rvores Binrias de Busca


Operaes de busca, insero e remoo de elementos so simples. O tempo dessas operaes, no pior caso linear. O tempo mnimo, logartmico, s ocorre se a rvore estiver perfeitamente balanceada.

rvores de Busca Balanceadas


As operaes de insero e remoo de elementos numa rvore de busca balanceada garantem que a rvore se mantm balanceada aps a sua realizao. As tcnicas utilizadas nesse sentido em geral envolvem
campos adicionais em cada n, para controle do balanceamento ou rvores de ordem maior que 2

rvores AVL
rvore balanceada tipo AVL:
para todos os seus ns, a diferena de altura entre as sub-rvores esquerda e direita no mximo 1. (Adel'son-Vel'Skii e E. M. Landis)

rvore AVL de altura mxima


Para uma altura h, a rvore AVL com o nmero mximo de elementos pode construda de forma sistemtica
(vazia)
h=0 h=1 h=2 h=3 h=4

N(h) = N(h-1)+N(h-2)+1 Altura aproximada: 1.44 log2(n+2)

Implementao de rvores AVL


Cada n tem associado um fator de balanceamento que representa a diferena de altura entre as sub-rvores esquerda e direita. O fator de balanceamento pode ser
implcito - calculado a cada acesso, o que muito caro) explcito - cada n tem um campo a mais indicando o fator de balanceamento (-1, 0 ou +1)

Insero em rvores AVL


rvore vazia: a nova rvore 'nasce'
balanceada.

Insero do lado mais baixo: a altura final


se mantm (dois casos: esquerdo e direito).

Insero quando as alturas das subrvores so iguais: a altura final aumenta


mas a rvore continua satisfazento ao 'critrio AVL' (dois casos: esquerdo e direito).

Insero em rvores AVL


Insero do lado mais alto: necessrio um rearranjo da rvore. rotao simples:
inserir B N G G N
h-2 h-2 h-2 h-2

h-2

h-2

Insero em rvores AVL


rotao dupla:
inserir H N F I
h-2 h-3 h-3 h-2 h-3 h-3 h-2

ou

K I F N

h-2

H
ou

Implementao da rvore AVL


typedef struct tnode* tnodePtr; typedef struct tnode{ tnodePtr esq, dir; int fb; char * info; } tnode;

Rotao (simples) Esquerda


tnodePtr LL(tnodePtr b){ tnodePtr a = b->esq; tnodePtr t2 = a->dir; a->dir = b; b->esq = t2; return a; }

Rotao (simples) Direita


tnodePtr RR(tnodePtr b){ tnodePtr a = b->dir; tnodePtr t2 = a->esq; a->esq = b; b->dir = t2; return a; }

Rotao Dupla Esquerda-Direita


tnodePtr LR(tnodePtr c){ tnodePtr b = c->esq; tnodePtr a = b->dir; tnodePtr t2 = a->dir; tnodePtr t3 = a->esq; c->esq = t2; b->dir = t3; a->dir = c; a->esq = b; return a; }

Rotao Dupla Direita-Esquerda


tnodePtr RL(tnodePtr c){ tnodePtr b = c->dir; tnodePtr a = b->esq; tnodePtr t2 = a->esq; tnodePtr t3 = a->dir; c->dir = t2; b->esq = t3; a->esq = c; a->dir = b; return a; }

Insero na rvore AVL


/* devolve true se a altura da rvore aumentou */ int insereAVL(tnodePtr *p, char* k){ int cmp; if(*p == NULL) { *p = newnode(k,NULL,NULL); return true; } if(cmp = strcmp(k,(*p)->info)==0) return false; if(cmp < 0) { <<< INSERIR ESQUERDA >>> } else { <<< INSERIR DIREITA >>> } }

Insero Esquerda
if(insereAVL(&((*p)->esq),k)){ switch ((*p)->fb){ case 1: (*p)->fb = 0; return false; case 0: (*p)->fb = -1; return true; case -1: /*** rebalancear ***/ if(((*p)->esq)->fb == -1) *p = LL(*p); else { LR(*p); (*p)->fb = 0; << ajustar fb >> } return false; } }

Insero Direita
if(insereAVL(&((*p)->dir),k)){ switch ((*p)->fb){ case -1: (*p)->fb = 0; return false; case 0: (*p)->fb = 1; return true; case 1: /*** rebalancear ***/ if(((*p)->dir)->fb == 1) *p = RR(*p); else { (*p)->fb = 0; << ajustar fb >> } return false; } }

Referncias na WEB
AVL Tree algorithm Wikipedia AlgorithmDesign.net Animao de rvores AVL Animao de rvores AVL (2)

rvores de Busca de Ordem > 2


Cada n pode ter mais que um campo chave
K1 K2 K3

Chaves < K1

Chaves > K3 K1 < Chaves < K2 K2 < Chaves < K3

rvores 2-3-4
rvore de busca de ordem 4
Cada n interno pode ter 2, 3 ou 4 filhos (1, 2 ou 3 campos chave). Todas as folhas tm a mesma altura. animao

Insero em rvores 2-3-4


As operaes de insero e remoo em rvores 2-3-4 devem respeitar as restries quanto altura das folhas e nmero de filhos por n.
Se o n no ponto de insero tiver menos que 4 filhos, inserir o novo n nesse ponto, fazendo uma eventual redistribuio dos filhos. Se o n no ponto de insero tiver 4 filhos, quebrar esse no em 2 abrindo espao para o novo no. A quebra implica numa insero um nvel acima. Essa quebra nvel acima se propaga enquanto necessrio at a raiz.

rvores Rubro-Negras
As rvores 2-3-4 tm algumas desvantagens em conseqncia do nmero de filhos por n:
Nas inseres e retiradas, a complexidade dos rearranjos do tipo quebra e juno. Mais comparaes na horizontal

Arvores rubro-negras:
Implementam a mesma idia das rvores 2-3-4 usando a representao de rvores binrias.

rvores Rubro-Negras
A idia original baseada nas rvores 2-3-4

ou

rvores rubro-negras
Propriedades:
1. 2. 3.

4.

Todo n vermelho ou preto e a raiz preta. Toda folha preta. Se um n vermelho ento seus filhos so pretos. Todo caminho da raiz at qualquer folha tem sempre o mesmo nmero de ns pretos (mesma profundidade preta).

Caractersticas
Uma rvore rubro-negra com n ns tem altura menor ou igual a 2log(n+1). Uma busca numa rvore leva um tempo O(log n). Inseres e retiradas podem, se feitas como nas rvores binrias de busca normais podem destruir as propriedades rubronegras. Para restabelecer as propriedades, recorrese a rotao e recolorao dos ns

Rotao
rotao esquerda ou direita essa operao preserva a ordenao da rvore.
rotao direita esquerda

Insero - exemplo

10 3 1 15 20 Insere 5 1 3 5

10 15 20

A cor definida pelas propridades.

Insero - exemplo
10 3 1 5 15 20 Insere 7 1 3 5 7 10 Recolorao: o novo n comea com vermelho e alterado em caso de conflito. 3 Recolor. 1 5 7 20 15 10 15 20 n vermelho com N vermelho com filho vermelho.

Insero - Exemplo
10 3 1 5 7 15 20 Insere 8 1 3 5 7 10 8 3 Pai -> preto. Av -> vermelho. Rotao no av. Recolor & Rotate Recolor. 1 5 7 8 15 20 10 15 20 A recolorao anterior no funciona

Insero - exemplo
10 3 1 5 7 8 3 Recolor 1 5 7 8 9 15 9 20 Continua ... 15 20 10 5 8 Insere 9 1 3 7 10 15 20

Insero (cont.)
10 3 1 5 7 8 9 7 3 1 5 8 9 15 20 O problema ainda no foi eliminado ... 15 20 necessrio recolorir o pai e o av.

10

Rotao

Insero (cont)
10 7 3 1 5 8 9 15 Recolor. e rotao 20 1 5 8 9 15 20 3 7 10

Referncias na web
http://users.cs.cf.ac.uk/Paul.Rosin/CM0212/DEMOS/RBTree/redblack.h tml http://ww3.algorithmdesign.net/handouts/RedBlackTrees.pdf http://www.cs.buap.mx/~titab/files/RedBlackTrees.pdf http://www.cs.buap.mx/~titab/files/RedBlackTrees.pdf http://www.cs.dal.ca/~nzeh/Teaching/Fall%202003/3110/RedBlackTree s.pdf animao 1

rvores: Outras representaes


Dependendo da aplicao, pode ser necessrio usar outra representao para rvores. Exemplo:
typedef struct no* apno; typedef struct no { char* info; apno pai }

Um exemplo: classes de equivalncia (I)


inicialmente: p->pai = p; para todo elemento p. raiz: apno raiz(apno p){ apno r = p; if(r->pai == r) return r; return raiz(r->pai); } p e que so equivalentes ? bool equiv(apno p, apno q){ return(raiz(p) == raiz(q)); }

Um exemplo: classes de equivalncia (I)


fazer p e q equivalentes: void mkEquiv(apno p,apno q){ apno r = raiz(p); r->pai = raiz(q); }

rvore binria completa


Uma rvore binria de altura h completa se ela tiver 2h-1 ns.

rvore binria completa


Uma rvore binria completa pode ser representada num vetor v:
raiz em v[0] se um n est em v[i], seus filhos esto em v[2*i+1] e v[2*i+1]

rvore binria quase completa


Uma rvore binria quase completa tem todos os seus nveis completos exceto o ltimo, o qual tem apenas os elementos mais esquerda. Uma rvore binria quase completa tambm pode ser representada num vetor.

Filas de prioridade
Uma fila de prioridade uma rvore binria tal que
o valor associado a cada n maior (ou menor) que o valor associado a cada um dos seus filhos.

Implementao:
se a fila de prioridade for uma rvore completa ou quase completa, ela pode ser implementada num vetor.

Filas de prioridade
Rearranjo: o elemento fora de ordem trocado com o seu maior filho, sucessivamente at restabelecer a 'condio de ordem' na fila de prioridade. No exemplo: 'h' seria trocado com 'm' e depois trocado com 'k'.
h g d b c a f e i j m k

Filas de prioridade
Rearranjo 'morro abaixo' : supondo que a fila de prioridade implementada num vetor v e o valor da raiz est fora de ordem
void sift(int r, int m, int v[]) { int x = v[r]; while (2*r < m) { int f = 2*r+1; if ((f < m) && (v[f] < v[f+1])) ++f; if (x >= v[f]) break; v[r] = v[f]; r = f; O trecho do vetor que contm a } sub-rvore a ser rearranjada v[r] = x; delimitado por r e m. }

Filas de prioridade
Rearranjo 'morro acima' : a folha v[m] est fora de ordem
void upHeap(int r, int m, int v[]) { int x = v[m]; int j = m/2; while((j >= r)&&(v[j]< x)) { v[m] = v[j]; m = j; j = j/2; } v[m] = x; }

O trecho do vetor que contm a sub-rvore a ser rearranjada delimitado por r e m.

Filas de prioridade
Construo da fila a partir de um vetor em que os elementos no mantm nenhuma relao de ordem: A construo parte 'de baixo para cima' a partir do ltimo elemento da primeira metade do vetor (penltimo nvel) porque o ltimo nvel j est organizado (cada sub-rvore s tem um n).
void makePQueue (int n, int v[]) { int r; for (r = (n-1)/2; r >= 0; r--) sift(r, n-1, v); }

A construo da fila feita em tempo linear (!)

Filas de prioridade
Inserir um valor x na fila (supondo que existe espao no vetor):
v[++m] = x; upHeap(0,m,v);

Retirar o valor mais prioritrio da fila:


x = v[0]; v[0] = v[m--]; sift(0,m,v);

Heapsort
O algoritmo heapsort usa a fila de prioridade para ordenar um vetor: void heapsort (int n, int v[]) { int p, m, x; for (p = (n-1)/2; p >= 0; p--) sift(p, n-1, v); for (m = n-1; m >= 1; m--) { x = v[0], v[0] = v[m], v[m] = x; sift(0, m-1, v); } }

Referncia na web
Uma boa referncia na web, em portugues, sobre estruturas de dados e algoritmos, alm de uma introduo linguagem C, estilo de programao, etc: http://www.ime.usp.br/~pf/algoritmos/

rvores gerais
Conjunto T no vazio de objetos
um n raiz demais ns em conjuntos T1, ...Tm, rvores disjuntas.

rvores gerais
Representao binria