capta a noção elementar de ordemde chegada no processamento de tarefas, além da ordem de chegada é típico atender à prioridade

Transcrição

1 Fila de Prioridade (1) Fila capta a noção elementar de ordemde chegada no processamento de tarefas, além da ordem de chegada é típico atender à prioridade Fila de prioridade objectos na fila têmum número indicativo da sua prioridade procurar o próximo objecto a tratar: encontrar o mínimo da fila retirar o objecto a tratar da fila: apagar o mínimo Aplicações simulação baseada em eventos processamento de tarefas nos sistemas operativos FilaPrior v2-1 Fila de Prioridade (2) Fila simples (sem prioridades): elementos entram pela cauda da fila elementos saem pela cabeça da fila Fila de prioridades: cada elemento tem associada uma prioridade absoluta (por exemplo um número) ou relativa (por comparação com outro elemento) (*) elemento novos elementos passam à frente dos elementos com prioridade "inferior" e 2 d 3 c 3 b 2 a 1 elementos saem pela cabeça da fila prioridade (absoluta neste exemplo) (*) Na implementação em Java que se segue, guardam-se simplesmente elementos que implementam o interface Comparable, supondo-se que elem1.compareto(elem2) compara as prioridades dos dois elementos FilaPrior v2-2

2 Interface de Fila de Prioridade package weiss.nonstandard; // PriorityQueue interface // // ******************PUBLIC OPERATIONS********************* // Position insert( x ) --> Insert x // Comparable deletemin( )--> Return and remove smallest item // Comparable findmin( ) --> Return smallest item // boolean isempty( ) --> Return true if empty; else false // void makeempty( ) --> Remove all items // int size( ) --> Return size // void decreasekey( p, v)--> Decrease value in p to v // ******************ERRORS******************************** // Throws UnderflowException for findmin and deletemin when empty FilaPrior v2-3 Interface de Fila de Prioridade * PriorityQueue interface. * Some priority queues may support a decreasekey operation, * but this is considered an advanced operation. If so, * a Position is returned by insert. public interface PriorityQueue * The Position interface represents a type that can * be used for the decreasekey operation. public interface Position * Returns the value stored at this position. the value stored at this position. Comparable getvalue( ); FilaPrior v2-4

3 Interface de Fila de Prioridade * Insert into the priority queue, maintaining heap order. * Duplicates are allowed. x the item to insert. may return a Position useful for decreasekey. Position insert( Comparable x ); * Find the smallest item in the priority queue. thesmallest item. UnderflowException if empty. Comparable findmin( ); * Remove the smallest item from the priority queue. thesmallest item. UnderflowException if empty. Comparable deletemin( ); FilaPrior v2-5 Interface de Fila de Prioridade * Test if the priority queue is logically empty. true if empty, false otherwise. boolean isempty( ); * Make the priority queue logically empty. void makeempty( ); * Returns the size. current size. int size( ); FilaPrior v2-6

4 Interface de Fila de Prioridade * Change the value of the item stored in the pairing heap. * This is considered an advanced operation and might not * be supported by all priority queues. A priority queue * will signal its intention to not support decreasekey by * having insert return null consistently. p any non-null Position returned by insert. newval the new value, which must be smaller * than the currently stored value. IllegalArgumentException if p invalid. UnsupportedOperationException ifappropriate. void decreasekey( Position p, Comparable newval ); FilaPrior v2-7 Heap Binário Conveniente para implementara fila de prioridade pode ser suportado num array inserir e apagar mínimo : O(N log N) no pior caso inserir: tempo médio constante; encontrar mínimo : tempo constante no pior caso Propriedades do heap binário Estrutura correspondentea uma árvore binária completa enche por níveis, da esquerda para a direita representação implícita em array Ordem Parcialmente ordenado Nó X com pai P: chave de P é menor ou igual à chave de X FilaPrior v2-8

5 Exemplo de Heap Binário Uma representação possível do conjunto 13, 16, 19, 21, 24, 26, 31, 32, 65, 68 através de um heap binário: - visualização como árvore binária: J n=10 altura da árvore é 1+ºlog 2 nß - visualização como array (o que realmente é armazenado): posição livre para optimizar inserções mínimo pai de x i é x ºi/2ß FilaPrior v2-9 Inserção insert(14) J J65 26 J J J < 31 (pai) trocar J 31 J < 21 (pai) trocar J 31 J (pai) parar chama-se a isto "percolar para cima" na realidade, basta escrever o novo valor na posição final FilaPrior v2-10

6 Remoção do mínimo deletemin() troca com menor dos filhos J último valor passa para a raíz troca com menor dos filhos não tem mais filhos (ou não são menores) parar chama-se a isto "percolar para baixo" FilaPrior v2-11 Construir heap árvore não ordenada J31 19 J 32 J começar no pai do último nó, e percolar para baixo J31 19 J 65 J passar ao nó anterior e percolar para baixo J31 21 J 65 J J31 21 J 65 J J31 24 J 65 J J31 24 J 65 J heap binário! FilaPrior v2-12

7 Heap binário Inserção Eficiência do heap binário Requer uma operação de percolar para cima : O(log N) no pior caso, O(1) em média Remover mínimo Requer uma operação de percolar para baixo : O(logN) no pior caso e em média Reconstruir o heap percolar para baixo em cada nó, usando a ordem inversa de nível dos nós requer apenas O(N) operações Uma árvore completa de altura H tem 2 H+1-1 nós e a soma das alturas dos nós é N - H - 1 Prova: marcar caminhos de cada nó até uma folha usando o primeiro filho esquerdo e depois só filhos direitos FilaPrior v2-13 Heapsort Método de ordenação de arrays baseado em heaps binários Usar heap com valor máximo na raíz em vez de valor mínimo, e deletemax em vez de deletemin Construir heap tempo O(N) Remover o máximo sucessivamente de N elementos, N-1 elementos,..., 1 elemento tempo O(N log N) O heap é armazenado do lado esquerdo do array e cada valor máximo removido do heap passa para a posição imediatamente à direita do heap heap valores já ordenados deletemax Como o tempo de cada remoção é O(logN) no pior caso e em média, o tempo das N remoções é O(N logn) no pior caso e em média Tempo total de heapsort O(N log N) no pior caso e em média FilaPrior v2-14

8 Implementação de heap binário package weiss.nonstandard; public class BinaryHeap implements PriorityQueue private static final int DEFAULT_CAPACITY = 100; private int currentsize; // Number of elements in heap private Comparable [ ] array; // The heap array public BinaryHeap( ) currentsize = 0; array = new Comparable[ DEFAULT_CAPACITY + 1 ]; public BinaryHeap( Comparable [ ] items ) currentsize = items.length; array = new Comparable[ items.length + 1 ]; for( int i = 0; i < items.length; i++ ) array[ i + 1 ] = items[ i ]; buildheap( ); FilaPrior v2-15 heap binário - inserir * Insert into the priority queue. * Duplicates are allowed. x the item to insert. null, signifying that decreasekey cannot be used. public PriorityQueue.Position insert( Comparable x ) if( currentsize + 1 == array.length ) doublearray( ); // Percolate up inthole = ++currentsize; array[ 0 ] = x; for( ; x.compareto( array[ hole / 2 ] ) < 0; hole /= 2 ) array[ hole ] = array[ hole / 2 ]; array[ hole ] = x; return null; FilaPrior v2-16

9 Implementação de heap binário UnsupportedOperationException because no Positions * are returned by the insert method for BinaryHeap. public void decreasekey( PriorityQueue.Position p, Comparable newval ) throw new UnsupportedOperationException( "Cannot use decreasekey for binary heap" ); * Find the smallest item in the priority queue. thesmallest item. UnderflowException if empty. public Comparable findmin( ) if( isempty( ) ) throw new UnderflowException( "Empty binary heap" ); return array[ 1 ]; FilaPrior v2-17 heap binário - remover mínimo * Remove the smallest item from the priority queue. thesmallest item. UnderflowException if empty. public Comparable deletemin( ) Comparable minitem = findmin( ); array[ 1 ] = array[ currentsize-- ]; percolatedown( 1 ); return minitem; FilaPrior v2-18

10 Implementação de heap binário * Establish heap order property from an arbitrary * arrangement of items. Runs in linear time. private void buildheap( ) for( int i = currentsize / 2; i > 0; i-- ) percolatedown( i ); * Returns size. current size. public int size( ) return currentsize; FilaPrior v2-19 Implementação de heap binário * Test if the priority queue is logically empty. true if empty, false otherwise. public boolean isempty( ) return currentsize == 0; * Make the priority queue logically empty. public void makeempty( ) currentsize = 0; FilaPrior v2-20

11 heap binário - percolar * Internal method to percolate down in the heap. hole the index at which the percolate begins. private void percolatedown( int hole ) int child; Comparable tmp = array[ hole ]; for( ; hole * 2 <= currentsize; hole = child ) child = hole * 2; if( child!= currentsize && array[child + 1].compareTo(array[child])< 0 ) child++; if( array[ child ].compareto( tmp ) < 0 ) array[ hole ] = array[ child ]; else break; array[ hole ] = tmp; FilaPrior v2-21 heap binário - duplicar vector * Internal method to extend array. private void doublearray( ) Comparable [ ] newarray; newarray = new Comparable[ array.length * 2 ]; for( int i = 0; i < array.length; i++ ) newarray[ i ] = array[ i ]; array = newarray; FilaPrior v2-22

12 heap binário - testar // Test program public static void main( String [ ] args ) int numitems = 10000; BinaryHeap h1 = new BinaryHeap( ); Integer [ ] items = new Integer[ numitems - 1 ]; int i = 37; int j; for( i = 37, j = 0; i!= 0; i = ( i + 37 ) % numitems, j++ ) h1.insert( new Integer( i ) ); items[ j ] = new Integer( i ); for( i = 1; i < numitems; i++ ) if( ((Integer)( h1.deletemin( ) )).intvalue( )!= i ) System.out.println( "Oops! " + i ); BinaryHeap h2 = new BinaryHeap( items ); for( i = 1; i < numitems; i++ ) if( ((Integer)( h2.deletemin( ) )).intvalue( )!= i ) System.out.println( "Oops! " + i ); FilaPrior v2-23