Arvore_Rubro_Negra.pdf
-
Upload
dayene-carvalho -
Category
Documents
-
view
17 -
download
0
Transcript of Arvore_Rubro_Negra.pdf
Brunner K. NogueiraGustavo R. CorreiaIgor H. C. Pinheiro
Lucas S. MagalhãesRildo F. Garcia Jr.
Árvore Rubro-Negra
Uma árvore rubro-negra é um tipo de árvore de busca binária balanceada, um tipo de estrutura de dados, tipicamente usada para implementar vetores associativos. Ela é complexa, mas tem um bom pior-caso de tempo de execução para suas operações e é eficiente na prática: pode-se buscar, inserir, e remover em tempo O(log n), onde n é o número total de elementos da árvore. De maneira simplificada, uma árvore rubro-negra é uma árvore de busca binária que insere e remove de forma inteligente, para assegurar que a árvore permaneça aproximadamente balanceada.
Definição
Um nó é vermelho ou preto.A raiz é preta. (Esta regra é usada em algumas definições. Como a raiz pode sempre ser alterada de vermelho para preto, mas não sendo válido o oposto, esta regra tem pouco efeito na análise.)Todas as folhas(NIL) são pretas.Ambos os filhos de todos os nós vermelhos são pretos.Todo caminho de um dado nó para qualquer de seus nós folhas descendentes contem o mesmo número de nós pretos.
Propriedades
(Altura negra) A altura negra de uma árvore rubro-negra A, denotada an(A) é o número de nós negros que se encontram nos caminhos da raiz até uma folha.
Observe que, pela terceira condição da definição de árvore rubro-negra, esse número é bem definido. No caso da árvore acima, a altura negra é 3
Definição
47
32
5
15
40
68
60 88
54 61 75 90
50
47
Exemplo
Estrutura
Estrutura
typedef struct No { enum cor {PRETO,VERMELHO} cor; int info; struct No *esq, *dir, *pai;} NO;
Funções Auxiliares
Função Avô
NO * avo(NO *a){ if ((a != NULL) && (a->pai != NULL)) return a->pai->pai; else return NULL;}
Função Tio
NO * tio(NO *a){ NO *b = avo(a); if (b == NULL) return NULL; if (a->pai == b->esq) return b->dir; else return b->esq;}
Função Irmão
NO * irmao(NO *a){ if (a == a->pai->esq) return a->pai->dir; else return a->pai->esq;}
Funções de Organização
Todo nó a ser inserido por convenção é rubroSe após a inserção for quebrada qualquer propriedade da ARN devem ser feitas rotações e/ou inversão de cores dos nós para que sejam satisfeitas todas as propriedades As regras de inserção levam em consideração a cor do “tio” (o outro filho do pai do nó que recebeu o novo nó) do nó inserido
Definição
Insere
void insere(NO **a, int info){ if (*a == NULL) *a=criaNo(info); else if (info<(*a)->info) insere (&((*a)->esq), info); else insere(&((*a)->dir), info); organiza_caso1(a);}
Caso 1
void organiza_caso1(NO *a){ if (a->pai == NULL) a->cor = PRETO; else organiza_caso2(a);}
Caso 2
void organiza_caso2(NO *a){ if (a->pai->cor == PRETO) return; else organiza_caso3(a);}
Caso 3void organiza_caso3(NO *a){ NO *c = tio(a), *b; if((c!=NULL)&&(c->cor==VERMELHO)){ a->pai->cor = PRETO; c->cor = PRETO; b = avo(a); b->cor = VERMELHO; organiza_caso1(b); } else organiza_caso4(a);}
Caso 4void organiza_caso4(NO *a){ NO *b = avo(a); if ((a == a->pai->dir) && (a->pai == b->esq)){ rotacionar_esq(a->pai); a = a->esq; } else if ((a == a->pai->esq) && (a->pai == b->dir)){ rotacionar_dir(a->pai); a = a->dir; } organiza_caso5(a);}
Caso 5void organiza_caso5(NO *a){ NO *b = avo(a); a->pai->cor = PRETO; b->cor = VERMELHO; if ((a == a->pai->esq) && (a->pai == b->esq)) rotacionar_dir(b); else rotacionar_esq(b);}
Esquemas de Inserção
Esquema 1
w
v
q
t“tio”
φ π
ω Ω Φ
Esquema 2
w
v
q
t
φ π
ω Ω Φ
w
v
q
t
φ π
ω Ω Φ
w
v
q
t
φ π
ω Ω Φ
raiz
Esquema 3
w
v
q
t
φ π
ω Ω Φ
Esquema 4
w
v
qΩ
ω
πφ
( Antes )
v
q
πφ
w
Ωω
( Depois )
Esquema 5
w
v
qΩ
ω
πφ
( Antes )
q
v
φω
w
Ωπ
( Depois )
Funções de Remoção
A remoção em árvores rubro-negras pode ser realizada também com um número logarítmico de operaçõesO procedimento de remoção é composto de uma etapa de remoção em árvore binária de busca seguido de uma etapa de balanceamento, caso as propriedades rubro-negras teriam sido destruídas durante a operação
Regras de Remoção
Se o nó removido for rubro, a árvore continua rubro-negra, pois todas as condições da definição ficam válidas:
1. Os nós resultantes tem cor rubro ou negro2. A raiz, que era negra, não foi removida3. Nenhum nó negro foi removido, portanto todos os caminhos da raiz até uma folha tem um número igual de nós negros4. Os filhos de todos os nós rubros não removidos não foram alterados e portanto ficam negros
Regras de Remoção
Se o nó removido for negro, o número de nós de pelo menos um caminho foi decrementado e consequentemente a terceira condição ficou inválida. Quando isto acontece, dois tipos de solução são possíveis:
remoção preguiçosa- A remoção preguiçosa consiste em marcar o nó como removido, mas sem tira-lo da árvore. Nenhum remanejamento é necessário. Em compensação, os algoritmos de inserção e busca devem ser modificados para levar em conta que alguns nós da árvore devem ser considerados como ausentes. A adoção desta solução é possível quando as árvores rubro-negras são usadas no contexto de uma aplicação com poucas operações de remoçãoremoção efetiva - Através de um número logarítmico de operações, a remoção efetiva restabelece as propriedades para que a árvore seja rubro-negra. Essas operações são detalhadas em seguida
Regras de Remoção
Remove Filho
void remove_filho(NO *a){ NO *filho = eFolha(a->dir) ? a->esq : a->dir; troca_No(a, filho); if (a->cor == PRETO) { if (filho->cor == VERMELHO) filho->cor = PRETO; else apaga_caso1(filho); } free(a);}
Caso 1
void apaga_caso1(NO *a){ if (a->pai != NULL) apaga_caso2(a);}
Caso 2
void apaga_caso2(NO *a){ NO *d = irmao(a); if (d->cor == VERMELHO){ a->pai->cor = VERMELHO; d->cor = PRETO; if (a == a->pai->esq) rotacionar_esq(a->pai); else rotacionar_dir(a->pai); } apaga_caso3(a);}
Caso 3 void apaga_caso3(NO *a){ NO *d = irmao(a); if ((a->pai->cor == PRETO) && (d->cor == PRETO) && (d->esq->cor == PRETO) && (d->dir->cor == PRETO)){ d->cor = VERMELHO; apaga_caso1(a->pai); } else apaga_caso4(a);}
Caso 4void apaga_caso4(NO *a){ NO *d = irmao(a); if ((a->pai->cor == VERMELHO) && (d->cor == PRETO) && (d->esq->cor == PRETO) && (d->dir->cor == PRETO)){ d->cor = VERMELHO; a->pai->cor = PRETO; } else apaga_caso5(a);}
Caso 5void apaga_caso5(NO *a){ NO *d = irmao(a); if (d->cor == PRETO) { if ((a == a->pai->esq) && (d->dir->cor == PRETO) && (d->esq->cor == VERMELHO)){ d->cor = VERMELHO; d->esq->cor = PRETO; rotacionar_dir(d); } else if ((a == a->pai->dir)&&(d->esq->cor==PRETO) &&(d->dir->cor==VERMELHO)){ d->cor = VERMELHO; d->dir->cor = PRETO; rotacionar_esq(d); } }apaga_caso6(a);}
Caso 6void apaga_caso6(NO *a){ NO *d = irmao(a); d->cor = a->pai->cor; a->pai->cor = PRETO; if (a == a->pai->esq){ d->dir->cor = PRETO; rotacionar_esq(a->pai); } else{ d->esq->cor = PRETO; rotacionar_dir(a->pai); }}
Esquemas de Remoção Efetiva
Esquema 1
w
v
φω
π
( Depois )
x
£€
v
w
φ
ω
π
( Antes )
x
£€
Esquema 2
w
φ
ω
π
( Antes )
x
£€
vc
w
φ
ω
π
( Depois )
x
£€
vc
Esquema 3
w
ω
Ω
( Antes )
x
£€
vc
z
φ π
z
ωφ
( Depois )
x
£€
vc
w
π Ω
Esquema 4
w
ωφ
( Antes )
x
£€
vc
z
π Ω
z
φ
( Depois )
x
£€
wc
v
π Ω
Comparação Entre Árvores
Comparação Entre Árvores