AED Algoritmos e Estruturas de Dados LEEC - 2005/2006

Filas com Prioridade

Filas com prioridade - Introduo (1)

Filas com prioridade (Priority Queues) usadas em diversas aplicaes:
Despacho (scheduler) de tarefas. Compresso de ficheiros. Algoritmos de ordenao.

Operaes mais usuais em filas com prioridade:

Criar fila, a partir de um conjunto de items Inserir novo item Remover o item com prioridade mais elevada Remover um item Modificar a prioridade de um item Juntar duas filas de prioridade
AED (IST/DEEC) 2

Filas com prioridade - Introduo (2)

Interface do tipo abstracto:
void PQinit(int); /* inicializa fila com prioridade, com nmero mximo de items */ BOOL PQempty(); /* testa fila vazia */ void PQinsert(Item); /* insere item */ Item PQdelmax(); /* elimina item de maior prioridade */

Nas filas de prioridade, todos os elemento possuem uma chave, que pode ser usada para ordenar a fila
Chave maior (ou menor) pode corresponder a maior prioridade
AED (IST/DEEC) 3

Filas com prioridade por tabela (1)

Implementao por tabela no ordenada
#include <stdlib.h> #include Item.h /* aqui o cliente define os dados */ static Item *queue; static int free; /* primeira posio livre*/ void PQinit(unsigned Size) { queue = (Item *) malloc(Size * sizeof(Item)); free = 0; } void PQinsert(Item I) { /*elemento inserido sempre na primeira posio livre*/ queue[free++] = I; } BOOL IsEmpty() { return free == 0 ? TRUE : FALSE; } AED (IST/DEEC)

PQinsert(i1); PQinsert(i3); PQinsert(i2);

i2
free=3
4

i3 i1

Filas com prioridade por tabela (2)

Item PQdelmax() { /* elimina elemento de maior chave */ int Idx, Max; /* procura elemento com maior chave */ for(Idx=1, Max=0; Idx<free; Idx++) if(less(queue[Max], queue[Idx])) Max = Idx; exch(queue[Max], queue[free-1]); /* troca topo com o elemento de maior chave */ return(queue[--free]); }

Seja Key(i3)>Key(i2)>Key(i1)

PQdelmax() d:

i2
free=3
AED (IST/DEEC)

i3 i1

free=2

i2 i1
5

Filas com prioridade por tabela (3)

Tabela ordenada pela chave
Insero e remoo de um elemento com prioridade qualquer, exige varrimento da tabela para deslocar items (no pior caso, toda a tabela). Procura e remoo do elemento com maior chave em tempo constante (acesso imediato ao topo).

A implementao das filas de prioridade por acervos (heaps) permite o melhor equilbrio no desempenho da procura (e remoo) de elementos com maior e com prioridade qualquer.

AED (IST/DEEC)

Filas com prioridade por tabela (4)

Complexidade, no pior caso, das operaes das filas com prioridade (segundo algumas implementaes)

Insero Tabela ordenada Tabela no ordenada Acervo (Heap) N 1 lg N

Remover chave mxima 1 N lg N

Remover N 1 lg N

Encontrar chave mxima 1 N 1

Modificar prioridade N 1 lg N

Juno N N N

AED (IST/DEEC)

Acervos (1)
Definio Um acervo (heap) uma representao, em tabela, de uma rvore que satisfaz a condio de acervo (heap condition) : o valor da chave associada a cada n superior (ou inferior) ao valor das chaves associadas em todos os ns de altura inferior
A ordenao dos acervos parcial (heap-ordering) Vantagens da representao de rvores por tabela
Menor ocupao de memria Acesso constante a qualquer elemento Necessrio conhecer tamanho partida
8

Inconvenientes da representao de rvores por tabela

AED (IST/DEEC)

Acervos (2)
Conveno (exemplo): nos acervos, a prioridade maior quanto menor for o nmero.
#define lessPri(A, B) (key(A) > key(B))

(pode ser exactamente o contrrio; uma conveno) A criao de um acervo, a partir de uma rvore, feita percorrendo a rvore em largura (breadht-first). Se rvore no for completa, existem casas vazias: a soluo impor que todos os ns intermdios sejam preenchidos.

AED (IST/DEEC)

Acervos (3)
Exemplo A1: Acervo de 12 posies
3

3
5 7

9 12 16 20 25 22 28 32 40

20

O n ascendente da posio i (i-1)/2

Exemplo: n ascendente da posio 6 (prioridade 20), est na posio (6-1)/2 = 2 (prioridade 7)

12

16

25 22 28 32 40

Os ns descendentes da posio i so 2i+1 e 2(i+1)

Exemplo: ns descendentes da posio 0 (prioridade 3), esto nas posies 1 (prioridade 5) e 2 (prioridade 7) Exemplo: ns descendentes da posio 2 (prioridade 7), esto nas posies 5 (prioridade 16) e 6 (prioridade 20)

Nota! No livro do Sedgewick, os ndices da tabela so considerados a partir de 1, Aqui usamos a conveno do C (a partir de 0)
AED (IST/DEEC) 10

Acervos (4)
Alterao/insero/remoo de um elemento pode quebrar a condio dos acervos.
Exemplo: se a chave for decrementada (valor substitudo por outro maior), os descendentes podem passar a ter chaves maiores (valores menores). Nota: decrementar baixar a prioridade Se a chave for decrementada, verificar ns de alturas inferiores descendo o caminho at folha Se a chave for incrementada, verificar ns de alturas superiores subindo o caminho at raiz

AED (IST/DEEC)

11

Sntese da Aula 1 de Filas com Prioridade

Introduo s filas com prioridade Operaes abstractas
Implementao por tabelas no-ordenadas Introduo aos acervos (heaps)

AED (IST/DEEC)

12

Acervos (5)
Reposio da ordenao num acervo
A. Se prioridade de um n for aumentada, enquanto no for restabelecida a condio de acervo ou atingida a raiz, trocar com o n ascendente.
void FixUp(Item Heap[], int Idx) { while (Idx > 0 && lessPri(Heap[(Idx-1)/2], Heap[Idx])) { exch(Heap[Idx], Heap[(Idx-1)/2]); Idx = (Idx-1)/2; } }

Fcil verificar que FixUp O(lg N)

AED (IST/DEEC)

13

Acervos (6)
Exemplo A2: No exemplo A1, n de prioridade 28 (posio 9) passa a ter prioridade 4
3 5 7

9 12 10 20 25 22 4 32 40

12

10

20

Heap[9]=4, Heap[(9-1)/2]=12
25 22 4 32 40

lessPri(Heap[4], Heap[9]): trocar e chamar FixUp sobre a posio 4

AED (IST/DEEC)

14

Acervos (7)
3 5 7

4 10 20 25 22 12 32 40

10

20

Heap[4]=4, Heap[(4-1)/2]=5
25 22 12 32 40

lessPri(Heap[1], Heap[4]): trocar e chamar FixUp sobre a posio 1

AED (IST/DEEC)

15

Acervos (8)
3 4 7

5 10 20 25 22 12 32 40

10

20

Heap[1]=4, Heap[(1-1)/2]=3
25 22 12 32 40

!lessPri(Heap[0], Heap[1]): condio de acervo satisfeita!!

AED (IST/DEEC)

16

Acervos (9)
B. Se prioridade de um n for diminuda, enquanto no restabelecer a condio de acervo ou atingir uma folha, trocar com o maior descendente.
void FixDown(Item Heap[], int Idx, int N) { int Child; /* ndice de um n descendente */ while(2*Idx < N) { /* enquanto no chegar s folhas */ Child = 2*Idx+1; /* selecciona o maior descendente. Nota: se ndice Child N-1, ento s h um descendente */ if (Child < N && lessPri(Heap[Child], Heap[Child+1])) Child++; if (!lessPri(Heap[Idx], Heap[Child])) break; /*condio acervo satisfeita */ exch(Heap[Idx], Heap[Child]); /* continua a descer a rvore */ Idx = Child; }}

Fcil verificar que FixDown O(lg N)

AED (IST/DEEC) 17

Acervos (10)
Exemplo A2: No exemplo A1, n de prioridade 3 (posio 0) passa a ter prioridade 14
14 5 7

14 5

9 12 10 20 25 22 28 32 40

12

10

20

Idx=0, Child=2*0+1=1
25 22 28 32 40

!lessPri(Heap[1],Heap[2]): foca na subrvore esq. lessPri(Heap[0],Heap[1]): troca e chama FixDown sobre a posio 1

AED (IST/DEEC)

18

Acervos (11)
5 14 7

5 14 7

9 12 10 20 25 22 28 32 40

12

10

20

Idx=1, Child=2*1+1=3
25 22 28 32 40

!lessPri(Heap[3],Heap[4]): foca na subrvore esq. lessPri(Heap[1],Heap[3]): troca e chama FixDown sobre a posio 3

AED (IST/DEEC)

19

Acervos (12)
5 9 7

7 14 12 10 20 25 22 28 32 40

14

12

10

20

Idx=3, Child=3*1+1=7
25 22 28 32 40

lessPri(Heap[7],Heap[8]): foca na subrvore dir. !lessPri(Heap[3],Heap[8]): condio de acervo satisfeita

AED (IST/DEEC)

20

Filas com prioridade por acervo (1)

#include Item.h /* aqui o cliente define os dados */ static Item *queue; static int free; /* nmero de elementos existentes no acervo */ void PQinit(unsigned Size) { queue = (Item *)malloc(Size*sizeof(Item)); free = 0; } void PQinsert(Item I) { /* insere novo elemento no fim e restabelece ordenao com FixUp */ queue[free] = I; FixUp(queue, free); free++; }

AED (IST/DEEC)

21

Filas com prioridade por acervo (2)

Item PQdelmax() { /* troca maior elemento com ltimo da tabela e reordena com FixDown */ exch(queue[0], queue[free-1]); FixDown(queue, 0, free-2); /* ultimo elemento no considerado na reordenao */ return queue[--free]; }

AED (IST/DEEC)

22

Ordenao por acervo (1)

O algoritmo de ordenao, usando uma fila com prioridade, muito simples:
1. 2. Inserir a tabela numa fila com prioridade, implementada por acervo. Chamar PQdelmax() para identificar a tabela inversamente ordenada.

void PQsort(Item pTable[], int L, int R) { int Aux; PQinit(R-L+1); for(Aux = L; Aux <= R; Aux++) PQinsert(pTable[Aux]); for(Aux = R; Aux >= L; Aux--) pTable[Aux] = PQdelmax(); }

AED (IST/DEEC)

23

Ordenao por acervo (2)

Complexidade do processamento: melhor que N lg N
Inicializao: O(1) Insero: lg 1 + lg 2 + ... + lg N (< N lg N) Retirada dos elementos do acervo: lg N + ... + lg 2 + lg 1 (< N lg N)

Complexidade da memria extra: N, para o acervo A memria extra pode ser eliminada, se o acervo for construdo na prpria tabela a ordenar.
Primeiro, constroi-se o acervo chamado FixDown na metade inicial da tabela. Depois, troca-se a raiz com o ltimo elemento e faz-se o FixDown sobre a tabela de dimenso menos 1)
24

AED (IST/DEEC)

Ordenao por acervo (3)

void Heapsort(Item Table[], int L, int R) { int Aux, Top = R; /* Constroi acervo na propria tabela, exercendo FixDown na parte inferior */ for(Aux = L+(R-L)/2; Aux >= L; Aux--)

FixDown(Table, Aux, R); /* Reordena a tabela, trocando o topo e exercendo FixDown na tabela com dimenso 1 ( na troca, o menor j colocado na posio final) */ while(Top > L){ exch(Table[L], Table[Top]); FixDown(Table, L, --Top); }

}
AED (IST/DEEC) 25

Ordenao por acervo (4)

Anlise da complexidade Construo do acervo custa O(N)
Os k maiores elementos (K<<N) podem ser identificados em O(N), bastando interromper o 2 ciclo ao fim de k iteraes.

Ordenao custa sempre O(N lg N), qualquer que seja o formato da entrada ver exemplos no Sedgewick .5

AED (IST/DEEC)

26

Sntese da Aula 2 de Filas com Prioridade

Reposio nos acervos
Ascendente Descendente

Implementao de filas, com prioridade, por acervos Ordenao por acervo

AED (IST/DEEC)

27