ECOI08 Aula 8

Prof. Rafael Santos

Email: rafafic@gmail.com
 Fila de Prioridades
uma estrutura de dados onde a chave de
cada item reflete sua habilidade relativa de
abandonar o conjunto de itens rapidamente.
Aplicaes:
SOs usam filas de prioridades, nas quais as
chaves representam o tempo em que eventos
devem ocorrer.
Mtodos numricos iterativos so baseados na
seleo repetida de um item com maior (menor)
valor.
Sistemas de gerncia de memria usam a tcnica
de substituir a pgina menos utilizada na memria
principal por uma nova pgina.
 Fila de Prioridades
Filas de Prioridades - Tipo Abstrato de Dados
Operaes:
1. Constri uma fila de prioridades a partir de um conjunto com n
itens.
2. Informa qual o maior item do conjunto.
3. Retira o item com maior chave.
4. Insere um novo item.
5. Aumenta o valor da chave do item i para um novo valor que
maior que o valor atual da chave.
6. Substitui o maior item por um novo item, a no ser que o novo
item seja maior.
7. Altera a prioridade de um item.
8. Remove um item qualquer.
9. Ajunta duas filas de prioridades em uma nica.
 Fila de Prioridades
Representao
Representao atravs de uma lista linear ordenada:
Constri ???
Insere ???
Retira ???
Ajunta ???
 Fila de Prioridades
Representao
Representao atravs de uma lista linear no
ordenada:
Constri ???
Insere ???
Retira ???
Ajunta ???
 Fila de Prioridades
Representao
Representao atravs de uma lista linear ordenada:
Neste caso, Constri leva tempo O(n log n).
Insere O(n).
Retira O(1).
Ajunta O(n).
Representao atravs de uma lista linear no
ordenada:
Neste caso, Constri tem custo linear.
Insere O(1).
Retira O(n).
Ajunta O(1) para apontadores e O(n) para arranjos.
 Heap- Fila de Prioridades
Representao
A melhor representao atravs de uma estruturas
de dados chamada heap:
Neste caso, Constri O(n).
Insere, Retira, Substitui e Altera so O(log n).

Observao:
Para implementar a operao Ajunta de forma
eficiente e ainda preservar um custo logartmico para
as operaes Insere, Retira, Substitui e Altera
necessrio utilizar estruturas de dados mais
sofisticadas, tais como rvores binomiais (Vuillemin,
1978).
 Heap
Heaps
uma seqncia de itens com chaves
c[1], c[2], ... , c[n], tal que:
c[i] c[2i],
c[i] c[2i + 1],
para todo i = 1, 2, ... , n/2.
Heap
A definio pode ser facilmente visualizada em uma
rvore binria completa:

rvore binria completa:

Os ns so numerados de 1 a n.
O primeiro n chamado raiz.
O n k / 2 o pai do n k , para
1 k n.
Os ns 2k e 2k 1 so os filhos
esquerda e direita do n k , para
1 k k / 2.
 Heap

Uma rvore binria um Heap se:

As chaves na rvore satisfazem a
condio do heap.
A chave em cada n maior do que as
chaves em seus filhos.
A chave no n raiz a maior chave do
conjunto.
 Heap
Heaps
Uma rvore binria completa pode ser representada
por um array:

A representao extremamente compacta.

Permite caminhar pelos ns da rvore facilmente.
Os filhos de um n i esto nas posies 2i e 2i + 1.
O pai de um n i est na posio i div 2.
 Heap
Heaps
Na representao do heap em um arranjo, a maior
chave est sempre na posio 1 do vetor.
Os algoritmos para implementar as operaes sobre o
heap operam ao longo de um dos caminhos da rvore.
Um algoritmo elegante para construir o heap foi
proposto por Floyd em 1964.
O algoritmo no necessita de nenhuma memria
auxiliar.
Dado um vetor A[1], A[2], ... , A[n].
Os itens A[n/2 + 1], A[n/2 + 2], ... ,A[n] formam um heap:
Neste intervalo no existem dois ndices i e j tais que j = 2i ou
j = 2i + 1.
 Heap

Os itens de A[4] a A[7] formam um heap.

O heap estendido para a esquerda (Esq = 3), englobando o item
A[3], pai dos itens A[6] e A[7].
A condio de heap violada:
O heap refeito trocando os itens D e S.
O item R incluindo no heap (Esq = 2), o que no viola a condio
de heap.
O item O incluindo no heap (Esq = 1).
A Condio de heap violada:
O heap refeito trocando os itens O e S, encerrando o processo.
 Heap
void Refaz(Indice Esq, Indice Dir, Item *A){
Indice i = Esq;
int j;
Item x;
j = i * 2;
x = A[i];
while(j <= Dir){
if (j < Dir){
if (A[j].Chave < A[j+1].Chave)
j++;
}
if (x.Chave >= A[j].Chave) goto L999;
A[i] = A[j];
i = j;
j = i * 2;
void Constroi(Item *A, Indice *n){
}
Indice Esq;
L999:
Esq = *n / 2 + 1;
A[i] = x;
while (Esq > 1){
}
Esq--;
Refaz(Esq, *n, A);
}
}
 Heap

//Retirar o maior elemento do heap

Item RetiraMax (Item *A ; Indice *n){
item aux;
if (*n < 1)
cout << Erro : heap vazio ;
else {
aux = A[1];
A[1] = A[*n];
*n = *n - 1;
Refaz (1,*n,A);
return aux;
}
}
Heap
Exemplo da operao de aumentar o valor da chave do item
na posio i:

O tempo de execuo do procedimento AumentaChave em um item do

heap O(log n). Algoritmo no Livro.
 Heap

//Insere novo item no heap

const int Infinito = MaxInt;
void Insere (Item *x; Item *A ; Indice *n){
*n = *n + 1;
A[*n] = *x;
A[*n].Chave = Infinito;
AumentaChave(*n, *x.Chave, A) ;
end;
 Heapsort
Possui o mesmo princpio de funcionamento
da ordenao por seleo.
Algoritmo:
1. Selecione o menor item do vetor.
2. Troque-o com o item da primeira posio do vetor.
3. Repita estas operaes com os n -1 itens
restantes, depois com os n - 2 itens, e assim
sucessivamente.
O custo para encontrar o menor (ou o maior)
item entre n itens n - 1 comparaes.
Isso pode ser reduzido utilizando uma fila de
prioridades.
Heapsort

Algoritmo:
1. Construir o heap.
2. Troque o item na posio 1 do vetor (raiz do
heap) com o item da posio n.
3. Use o procedimento Refaz para reconstituir o
heap para os itens A[1], A[2], ... ;A[n-1].
4. Repita os passos 2 e 3 com os n-1 itens
restantes, depois com os n-2, at que reste
apenas um item.
 Heapsort
void Heapsort(Item *A, Indice *n)
{
Indice Esq, Dir;
Item x;
Constroi(A, n); /* constroi o heap */
Esq = 1;
Dir = *n;
while (Dir > 1)
{
/* ordena o vetor */
x = A[1];
A[1] = A[Dir];
A[Dir] = x;
Dir--;
Refaz(Esq, Dir, A);
}
}
Heapsort
O procedimento Refaz gasta cerca de log n
operaes, no pior caso.
Logo, Heapsort gasta um tempo de execuo
proporcional a n log n, no pior caso.
Vantagens:
O comportamento do Heapsort sempre O(n log n),
qualquer que seja a entrada.
Desvantagens:
O anel interno do algoritmo bastante complexo se
comparado com o do Quicksort.
O Heapsort no estvel.
Heapsort

Recomendado:
Para aplicaes que no podem tolerar
eventualmente um caso desfavorvel.
No recomendado para arquivos com
poucos registros, por causa do tempo
necessrio para construir o heap.
 Referncia Bibliografia

ZIVIANI, Nivio. Projeto de Algoritmos com implementao em Pascal e C.

2a Edio. Ed. Pioneira Thomson Learning, 2004.
Todas as informaes dos slides foram retiradas da Transparncias do livro
acima acessados no site:
http://www.dcc.ufmg.br/algoritmos-edicao2/cap1/transp/completo1/cap4.pdf