Filas de prioridade. Marcelo K. Albertini. 3 de Dezembro de 2013

Transcrição

1 Filas de prioridade Marcelo K. Albertini de Dezembro de

2 / Filas de prioridade O que é uma fila de prioridade? Estrutura de dados que generaliza a ideia de ordenação. Coleções de elementos: inserir e remover itens. Qual remover? Pilha - remover o item mais novo Fila - remover o item mais velho Fila aleatorizada - remover item mais aleatório Fila de prioridade - remover o maior ou menor item

3 / Exemplo de uso de filas de prioridade operação inserir inserir inserir remover máximo inserir inserir inserir remover máximo inserir inserir inserir remover máximo item valor obtido P Q E Q X A M X P L E P

4 Aplicações Simulação orientada a eventos clientes em uma fila colisão de partículas Compressão de dados Código de Huffman Busca em grafos Algoritmo de Dijkstra Algoritmo de Prim Inteligência artificial Busca A* Sistemas operacionais balanceamento de carga manipulação de interrupções Filtragem de spam bayesiano Ranking web Generalização de pilhas, filas, filas aleatórias /

5 / Tipo abstrato de dados - API public class MaxFilaP <Chave extends Comparable<Chave> > MaxFilaP() criar fila de prioridade vazia MaxFilaP(Chave[] v) criar fila com chaves void inserir(chave c) inserir chave na fila Chave removermax() retornar e remover chave máxima boolean estavazio() a fila está vazia? Chave max() retorna chave máxima int size() número de entradas na fila Chave deve ser Comparable

6 / Exemplo de uso de fila de prioridade Encontrar os M maiores itens de uma sequência N itens Detecção de fraudes e ataques em redes de computadores Processamento de consultas em buscador web Restrição não há espaço de memória para guardar os N itens Exemplo:detecção de fraudes Marcelo $ Joao $ Maria $ Paulo $ Beatriz $... Suspeitos: Paulo $ Joao $

7 / Meta Encontrar os M maiores itens de uma sequência N itens: usar uma MinFilaP. MinFilaP<Pagina> minfila = new MinFilaP<Pagina >(); BufferedReader teclado = new BufferedReader(new FileReader (System. in )) ; String consulta = teclado. nextline () ; while ( teclado. hasnextline () ) { String linha = teclado. nextline () ; Pagina p = new Pagina( linha, consulta ) ; // cada pagina guarda um valor de relevancia para a consulta minfila. inserir (p) ; if ( minfila. size () > M) minfile. removermin() ; }

8 / Meta Encontrar os M maiores itens de uma sequência N itens: usar uma MinFilaP. Complexidades implementação tempo espaço fila elementar m n m ordenação n log n n heap binária n log m m melhor teórico n m

9 public class MaxFilaDesordenada<Chave extends Comparable<Chave>> { private Chave [] fila ; // fila [ i ] = i esimo elemento private int N; public MaxFilaDesordenada( int capacidade) { fila = (Chave []) new Comparable[ capacity ]; } public boolean estavazio () { return N==; } public inserir (Chave c) { fila [N++] = c; } public Chave removermax() { int max = ; for ( int i =; i < N; i++) if ( fila [max]. compareto( fila [ i ]) < ) max = i ; troca (max, N ); return fila[ N]; } } /

10 / Implementação de filas de prioridade Meta Implementar todas as operações eficientemente. Implementação inserção remoção vetor desordenado N vetor ordenado N meta log n log n

11 / Heap binária O que é? Heap binária é uma estrutura de dados que permite a execução eficiente das operação de inserção e remoção em filas de prioridade. Heap binária é um tipo de árvore

12 / Árvores Árvore binária Vazia ou nós com ligações à direita ou à esquerda para outras árvores. Árvore binária completa Perfeitamente balanceada. Cada nível possui todos os nós possíveis, exceto, possivelmente o último. altura de uma árvore binária é logn altura aumenta quando N for potência de :

13 /

14 / Heap binária Uma árvore binária completa Chaves estão em nós Chaves-pais não são menores que chaves-filhas T S R P N O A E I H G

15 Propriedades da heap binária Implementação em um vetor Maior chave está em v[], que é a raiz da árvore binária Usa posições do vetor para ligações entre nós Nó pai do nó na posição k está na posições (k/) Lembre-se. = Filhos do nó na posição k estão em k e k + T S R P N O A E I H G T S R P N O A E I H G /

16 / Implementação de operações da heap binária Propriedades invariantes da heap binária devem ser sempre mantidas Na inserção ou remoção de chaves, verificar e corrigir violações de propriedades

17 / Promoção em heap binária Cenário Chave-filha torna-se maior que chave-pai. Isso provoca uma violação de regras da heap. Para eliminar a violação Trocar chave-folha com chave-pai Repetir até corrigir todas as violações T Z S R T R P N O A S N O A Z I H G P I H G

18 / Promoção em heap: algoritmo Elemento fila[k/] deve ser maior que fila[k], se não for devemos trocá-los. void promocao( int k) { while (k > && ( fila [k/].compareto( fila [k])< )) { troca (k, k/) ; // troca pois fila [k/] < fila [k] k = k/; // sobe na árvore com divisão inteira } }

19 / Inserção em heap binária Inserção: Inserir nó no fim do vetor e aplique a promoç~ao Custo: No máximo +logn comparações void insercao (Chave c) { fila[++n] = c; promocao(n) ; }

20 / void insercao (Chave c) { fila[++n] = c; promocao(n) ; } void promocao( int k) { while (k > && ( fila [k/].compareto( fila [k]) < )) { troca (k, k/) ; k = k/; } } Inserção da chave = Começar com inserção no fim.

21 / void insercao (Chave c) { fila[++n] = c; promocao(n) ; } void promocao( int k) { while (k > && ( fila [k/].compareto( fila [k]) < )) { troca (k, k/) ; k = k/; } } Inserção da chave = Promoção no lugar do pai / =

22 void insercao (Chave c) { fila[++n] = c; promocao(n) ; } void promocao( int k) { while (k > && ( fila [k/].compareto( fila [k]) < )) { troca (k, k/) ; k = k/; } } Promoção no lugar do pai / = Inserção da chave = /

23 void insercao (Chave c) { fila[++n] = c; promocao(n) ; } void promocao( int k) { while (k > && ( fila [k/].compareto( fila [k]) < )) { troca (k, k/) ; k = k/; } } Promoção no lugar do pai / = Inserção da chave = /

24 Demoção em heap binária Cenário Chave-pai se torna menor que alguma chave-filha. Violação! Para eliminar a violação Trocar chave na posição pai com chave na posição filha com maior chave. Porque não filho com menor chave? Repetir até resolver todas as violações A S S R P R N P O A N H O A B I H G B I A G /

25 / Implementação: demoção void democao( int k) { while ( k <= N) { int j = k; // filho da esquerda esta em j // compara com filho da direita para pegar maior if ( j < N && ( fila [ j ]. compareto( fila [ j +]) <)) j++; if ( fila [k ]. compareto( fila [ j ]) >= ) break ; // interromper processo de democao troca (k, j ) ; // efetuar democao k = j ; } }

26 Execução da demoção /

27 Execução da demoção /

28 Remover max = /

29 /

30 /

31 Remover max = /

32 /

33 /

34 Remover max = /

35 /

36 /

37 / Remover max =

38 /

39 /

40 / Remover max =

41 /

42 / Remover max =

43 /

44 / Remover max =

45 /

46 / Remover max =

47 /

48 / Remover max =

49 / Remover max =

50 / Operação removermax() Remover chave máxima Trocar raiz com nó no fim e aplicar o processo de demoção. public Chave removermax() { Chave max = fila []; troca (, N ); democao() ; fila [N+] = null ; // libera referência de objeto para coletor de lixo return max; } Custo No máximo logn comparações

51 / Custos de operações de listas de prioridade implementação inserção remover máximo ver máximo vetor desordenado N N vetor ordenado N heap binário log N log N heap d-ária log d N d log d N heap de Fibonacci log N impossível Porque ter todas as operações lineares é impossível?

52 / Observações gerais Lista de prioridade orientada ao mínimo Trocar operações de comparação compareto Outras operações Ao inserir, evitar overflow e usar operação de redimensionar vetor Ao remover, verificar e lançar exceção se fila está vazia Remoção de item arbitrário Mudar prioridade de item Usar operações: promocao e remocao

53 / Heapsort com ordenação no lugar (in-place) Ideia fazer in-place, ou seja, sem usar vetor auxiliar criar uma heap binária orientada ao máximo (max heap) com todas as chaves disponíveis aplicar removermax para cada uma das chaves, até acabar a heap

54 / Criação da heap in-place Primeira passada: criar heap usando método bottom-up. for ( int k = N/; k >= ; k ) democao(vet, k, N) ; Segunda passada: remover o máximo, um por vez, deixar elemento no vetor em vez de liberar memória (com null). while (N > ) { troca (vet,, N ); democao(vet,, N) ; }

55 / Análise matemática Construção da heap usa até N comparações e trocas Heapsort usa até NlogN comparações e trocas Heapsort é um algoritmo in-place com pior caso NlogN Comparações Mergesort: não é in-place (possível, porém não é prático) e usa O(n) espaço extra Quicksort: quadrático no pior caso Heapsort: NlogN, sem espaço extra iteração interna mais longa que do Quicksort (constante de complexidade maior no caso médio) Mal uso de caching pelo uso frequente de referências em posições não contínuas da memória Heapsort não é estável

56 / Tabela de algoritmos no lugar estável pior médio melhor comentário seleção S N / N / N / N trocas inserção S S N / N / N bom p/ pequeno N shell S?? N fácil e < N quick S N / N logn N logn mais rápido na prática quick S N / N logn N chaves duplicadas merge S N logn N logn N logn estável e garantido heap S N logn N logn N logn no lugar e garantido ideal S S N logn N logn N logn quick = quicksort em três partes