Árvore Hierárquica
Em inglês é chamada de Heap.
Representar: conjunto C de elementos com relação .
Operações: Insx, C (inserir x em C e ExMaxC (extrair o máximo do
conjunto).
Chamado também de Fila de Prioridade.
Definição: É uma árvore binária tal que:
1. Para um inteiro p 0 todas as folhas estão na profundidade p ou
p 1.
2. As de profundidade p estão todas "à esquerda" das de profundidade
p 1.
3. Conteúdo de um vértice v é conteúdo dos filhos de v.
30
9
1
6
2
30
9
1
6
2
1
elemento novo
30
Não é árvore
hierarquica
1
9
6
2
30
Não é árvore
hierarquica
1
6
9
2
As propriedades (1) e (2) implicam que a árvore é quase completa ou
completa.
Se todas as folhas ocorrem na profundidade p então a árvore é completa,
com profundidade 2 p1 1 vértices.
A propriedade (3) é chamada de hierarquização.
Se a relação de ordem for ao invés de , o mínimo ocorre na raiz.
Seja M um vetor na memória:
Mi
M2i
M 2i +1
Se M j é um filho então M j/2 é o pai, filho esquerdo ou direito
(j 2i 1 2i 1/2 i).
30
9
6
1
2
filho esq de
i
1
2
M 30 9
12 2
filho esq de
filho dir de
9
22 4
221 5
3
4
5
6
1
2
121 3
30
9
filho dir de
30
Vantagem: representação SEM apontador.
Operação de inserção Insx, C
8
3
2
6
1
5
conj. C, n = 6
9
(n+1) ésimo, novo
8
ELEM
3
9
-
9>6
2
1
5
6
Rebaixado
ELEM
9
9>8
9
3
8
Rebaixado
2
1
5
6
Exercício: Se o elemento novo fosse 7, ao invés de 9?
Algoritmo Insx, C
Entrada: vetor M que representa uma árvore hierárquica com n objetos, e
um objeto x
Saída: vetor M contendo x
1. ELEM x;
2. M n1 x; (* provisoriamente colocado como última folha *)
3. j n 1; i n 1/2; (* índice do pai *)
4. enqto i 0 e M i ELEM faça {
5. M j M i ; (* o pai é rebaixado *)
6. j i; i i/2; (* índice do novo pai, um nível acima *)
7. } (* fim do enqto *)
8. M j ELEM; (* coloca x no lugar correto *)
Complexidade: Olg n. Por quê?
9
lg(n + 1) − 1
3
2
8
1
5
6
Rebaixamento
Antes do algoritmo ExMaxC, veremos o algoritmo para rebaixar a raiz,
cujas subárvores esquerda e direita são árvores hieráquicas, mas a raiz
contém um objeto MENOR que os dois filhos, e portanto a árvore toda não
é hierarquica.
Rebaixar a raiz
Árv.Hierarq.
Árv.Hierarq.
6
Rebaixar
3
2
9
1
5
8
ELEM
6
Rebaixar
6<9
3
filho maior
9
2
1
5
9
8
Promovido
ELEM = 6
3
Rebaixar
6<8
2
1
5
8
filho maior
9
3
2
Promovido
8
1
5
6
Algoritmo Rebaixai, n
Entrada: vetor M que representa uma árvore hierárquica com n objetos, e
índice i da raiz a ser rebaixada (ou seja, M i é o vértice a ser rebaixado, que
pode ser raiz de uma subárvore).
Saída: vetor M contendo após rebaixar a raiz para o local apropriado
1. ELEM M i ; j 2 i; achou falso; (* M j é o filho esquerdo *)
2. enqto (j n) e (não achou) faça{ (* enqto há rebaixamento a ser
feito *)
3. se (j n e M j M j1 )
4.
então j j 1; (* M j é o filho maior *)
5. se (ELEM M j )
6.
então achou verdadeiro; (* terminar rebaixamentos *)
7.
senão {
8.
M j/2 M j ; (* filho maior é promovido *)
9.
j 2 j; (* índice do novo filho, um nível abaixo *)
10.
} (* fim-senão *)
11. } (* fim-enqto *)
12. M j/2 ELEM; (* a raiz original é colocada no nó pai de M j *)
Complexidade: Olg n. Por quê?
Operação de extração do max, ExMaxC
(1) O máximo está na raiz. Seja y o objeto na última folha M n .
max
Extrai
max
Árv. Hierarq.
y
última
folha
(2) Promove y para raiz, e tira M n da árvore, ou seja faz n n 1. A
árvore resultante não é mais hierárquica.
y
promove y
para raiz
não é mais
Árv. Hierarq.
tira última
folha
(3) Aplica o algoritmo Rebaixa, que rebaixa a raiz com y até o local
apropriado, tornando a árvore de novo em hierárquica.
y
Rebaixa raiz
de novo,
Árv. Hierarq.
Complexidade Olg n. Por quê?
Hierarquização
Objetivo: transformar uma árvore binária (representada por um vetor com
n objetos) em árvore hierárquica.
Solução: aplicar o Algoritmo Rebaixa da seguinte forma (note que as
folhas sozinhas já constituem uma árvore hierárquica):
1. Aplicar primeiro Rebaixa sobre cada pai das folhas, junto com as
folhas; resulta várias subárvores hierarquizadas com as raizes que são
pais das folhas;
2. A seguir aplicar Rebaixa sobre cada avô das folhas; resulta
hierarquização um nível acima;
3. E assim por diante, subindo de nível, até chegar à raiz.
Algoritmo Hierarq
Entrada: vetor M com n vértices
Saída: M hierarquizada
para i n/2 até 1 faça {
Rebaixa(i, n);
}
Exercício: a complexidade de tempo do Hierarq é Tn On. (solução
no livro.)
HeapSort (Ordenação por Hierarquização)
Objetivo: dado um vetor com n objetos, ordená-lo em ordem crescente.
Solução:
1. Aplicar o Algoritmo Hierarq sobre o vetor M. Resulta uma árvore
hierárquica em tempo On;
2. Aplicar ExMax n vezes. Resulta M ordenado em tempo On lg n.
3. Tempo total: On lg n.
Algoritmo OrdHierarq (ou HeapSort)
Entrada: vetor M com n objetos
Saída: M em ordem crescente
1. Hierarq(M, n);
2. para i n até 2 faça {
3. (* a seguir troca M 1 , o máximo, com M i *)
4. t M i ; M i M 1 ; M 1 t;
5.
6.
Rebaixa(1, i 1);
} (* fim-para *)
Início com M 25, 31, 26, 5, 6
Aplica Hierarq(M, 5) resulta em M max 31, 25, 26, 5, 6
Inicia laço “para i n ...”
i5
6, 25, 26, 5, max 31, Rebaixa1, 4 max 26, 25, 6, 5, 31
i4
5, 25, 6, max 26, 31, Rebaixa1, 3 max 25, 5, 6, 26, 31
i3
6, 5, max 25, 26, 31, Rebaixa1, 2 max 6, 5, 25, 26, 31
i2
5, max 6, 25, 26, 31 Rebaixa1, 1 max 5, 6, 25, 26, 31
Figura: Ilustração de execução do algoritmo OrdHierarq.
Resumo
1.
2.
3.
4.
5.
Inserir
Rebaixa
ExMax (ou ExMin)
Hierarq
OrdHierarq
Exercícios sobre Heap (Árvore Hierárquica).
1. Dada a matriz hieraquizada, com a relação :
índ. 1 2 3
M
4
5 6
7
8
9
10 11 12 13
4 5 6 15 9 7 20 16 25 14 12 11
8
a. Desenhar a árvore binária correspondente;
b. Inserir um novo objeto 2, aplicando o algoritmo Insx, C visto.
2. Considere a mesma árvore do exercício (1). Remover o mínimo
aplicando o algoritmo ExMinC.
3. Hierarquizar a matriz M a seguir, aplicando o algoritmo Hierarq
dado, com a relação
índ.
M
1
2 3
4
5
6
7 8 9 10 11 12 13 14 15
11 8 7 14 9 12 4 6 5 16 25 15 23 27 20
4. Ordenar a matriz a seguir, em ordem crescente, aplicando o
algoritmo OrdHierarq
índ
1
2
3
4
5
6 7
8
9
10
M
22 15 36 44 10 3 9 13 29 25
