Filas de prioridade. Marcelo K. Albertini. 27 de Novembro de 2014

Transcrição

1 Filas de prioridade Marcelo K. Albertini de Novembro 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 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 class MaxFila <Chave extends Comparable<Chave> > MaxFila() criar fila de prioridade vazia MaxFila(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 tamanho() número de entradas na fila Chave deve ser Comparable, ou seja, comparável com outras chaves e deve ter um método c.compareto(c) que retorna valor: negativo se c < c, ou zero se c == c ou positivo se c > c. /

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 MinFila. MinFila<Pagina> fila = new MinFila<Pagina >(); String consulta = receberconsulta () ; while ( teclado. naoterminou() ) { String linha = receberconsulta () ; // cada pagina tem um valor de relevancia p/ consulta Pagina p = new Pagina( linha, consulta ) ; fila. inserir (p) ; //remove menores p/ sobrar maiores if ( fila.tamanho() > M) // fila. removermin() ; }

8 / Meta Encontrar os M maiores itens de uma sequência N itens: usar uma MinFila. 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 // MaxFila : versão com vetor desordenado class MaxFila<Chave extends Comparable<Chave>> { Chave [] fila ; // fila [ i ] = i esimo elemento int N; public MaxFila( int capacidade) { fila = (Chave []) new Comparable[ capacity ]; } boolean estavazio () { return (N==); } inserir (Chave c) { fila [N++] = c; } 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 max-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 max-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 max-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 max-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 [] fila, int k, int N) { while ( k <= N) { int esq = k; // filho da esquerda int dir = k +; // filho da direita maior = esq ; // compara com filho da direita para pegar maior if (( fila [ esq ]. compareto( fila [ dir ])<)&&(esq < N)) maior = dir ; if ( fila [k ]. compareto( fila [ maior ]) >= ) break ; // interromper processo de democao troca (k, maior) ; // efetuar democao k = maior ; } }

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. Chave removermax() { Chave max = fila []; troca (, N) ; N ; democao() ; fila [N+] = null ; // libera memória 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: min-heap 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 / Heapsort com 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 O(NlogN) Comparações Mergesort: não é in-place e usa O(n) espaço extra Quicksort: quadrático no pior caso Heapsort: NlogN, sem espaço extra Mal uso de caching pelo uso frequente de referências em posições não contínuas da memória Não é estável Iteração interna mais longa que do Quicksort (constante de complexidade maior no caso médio)

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 de Dijkstra