Ordenação: Terminologia Interno (o arquivo é armazenado na memória principal e pode ser aleatoriamente acessado) x Externo (arquivo é armazenado em memória secundária, e pode ser acessado somente seqüencialmente) Ord. Baseada-comparações: utiliza somente as relações entre as chaves, nenhuma outra propriedade especial da apresentação das chaves é utilizada. Ord. Estável: registros com chaves iguais retêm sua ordem relativa original; i < j & Kpi = Kpj  pi < pj Baseada em Vetor (chaves consecutivas são armazenadas em localizações de memória consecutivas) x Baseada em Listas (pode ser armazenado em localizações não consecutivas) Ord. “In-place” : Necessita um montante constante de espaço extra em adição àquele necessário para armazenar as chaves.

Métodos de Ordenação Elementares Mais fácil de entender os mecanismos básicos de ordenamento Podem ser mais adequados para arquivos pequenos Bons para arquivos bem-comportados que são relativamente fáceis de ordenar, como por exemplo os arquivos quase ordenados Podem ser utilizados para melhorar a eficiência de métodos mais poderosos Ord. por Inserção insertion sort, shellsort Ord. por Troca bubble sort, quicksort Ord. por Seleção selection sort, heapsort Ord. por Fusão merge sort Ord. por Distribuição radix sort

Selection Sort Ordenação “In-place” Não é estável 1. for i = n to 2 do 2. max  i 3. for j = i - 1 to 1 do 4. if A[max]  A[j] then 5. max  j 6. t  A[max] 7. A[max]  A[i] 8. A[i]  t Ordenação “In-place” Não é estável O número de comparações é (n2) no pior caso, mas pode ser melhorado, conduzindo ao método heapsort (mostrado a seguir).

Heaps Heapsort Estrutura de Dado Mantendo a Propriedade Heap Construindo uma Heap Algoritmo Heapsort Fila de Prioridade Um vetor que pode ser visto como uma árvore binária completa. 16 14 10 8 7 9 3 2 4 1

Operações Básicas Pai (i) retorne i/2 Esquerda (i) retorne 2i Direita (i) retorne 2i+1

Propriedades Propriedade Heap: para todo nó i, com exceção da raiz, A[Parent(i)]  A[i] Altura de um nó em uma árvore: o número de arcos existentes no caminho mais longo de um nó para uma folha. A altura de uma árvore para uma heap é (lg n). Assim, as operações básicas de uma heap executam em O(lg n).

Mantendo a Propriedade Heap

Heapify (A, i) Heapify (A, i) 1. l  esquerda(i) 2. r  direita(i) 3. if l  heap-size[A] and A[l] > A[i] 4. then largest  l 5. else largest  i 6. if r  heap-size[A] and A[r] > A[largest] 7. then largest  r 8. if largest i 9. then troque A[i]  A[largest] 10. Heapify(A, largest)

Análise do Algoritmo O tempo de execução para qualquer nó i é (1), o tempo para corrigir o relacionamento entre A[i], A[Esquerda(i)] e A[Direita (i)], mais o tempo para executar Heapify sobre uma das sub-árvores filhas. E, cada sub-árvore filha têm tamanho de no máximo 2n/3 (o pior caso ocorre quando a última fileira da árvore está exatamente cheia até a metade). Assim, T(n)  T(2n/3) + (1)  T(n) = O(lg n) Alternativamente, Heapify requer O(h) onde h é a altura do nó ao qual Heapify é aplicada.

Build-Heap(A) Build-Heap(A) 1. heap-size[A]  length[A] 2. for i  length[A]/2 downto 1 3. do Heapify(A, i)

Tempo de Execução O tempo requerido por Heapify sobre um nó de altura h é O(h). De modo que nós podemos expressar o custo total de Build-Heap como  h=0 à lgn n / 2h+1 O(h) = O( n  h=0 à lgn h/ 2h ) e,  h=0 à  h/ 2h = (1/2) / (1 - 1/2)2 = 2 Portanto, O( n  h=0 à lgn h/ 2h ) = O(n) Assim, pode-se construir uma heap de um vetor aleatório em um tempo linear.

Heapsort (A) 1. Build-Heap(A) 2. for i  length[A] downto 2 3. do troque A[1]  A[i] 4. heap-size[A]  heap-size[A] - 1 5. Heapify(A, 1)

Análise do Algoritmo In-place Instável Build-Heap requer O(n) e cada uma das n-1 invocações de Heapify requer O(lg n). Portanto, T(n) = O(n lg n)

Filas com Prioridade Uma estrutura de dados visando a manutenção de um conjunto S de elementos, cada um com valor associado chamado chave. Aplicações: scheduling de trabalhos sobre um computador compartilhado, simulação de eventos discretos. Heap pode ser utilizada para implementar uma fila de prioridade.

Operações Básicas Insert(S, x) - insere o elemento x no conjunto S, i.e. S  S  {x} Maximum(S) - retorna o elemento de S com a maior chave. Extract-Max(S) - remove e retorna o elemento de S com a maior chave.

Heap-Extract-Max(A) 1. if heap-size[A] < 1 2. then erro “heap underflow” 3. max  A[1] 4. A[1]  A[heap-size[A]] 5. heap-size[A]  heap-size[A] - 1 6. Heapify(A, 1) 7. return max

Heap-Insert(A, key) 1. heap-size[A]  heap-size[A] + 1 2. i  heap-size[A] 3. while i > 1 and A[pai(i)] < key 4. do A[i]  A[pai(i)] 5. i  pai(i) 6. A[i]  key

Tempo de Execução Tempo de execução de Heap-Extract-Max é O(lg n). Executa somente um quantidade constante de trabalho sobre o topo de Heapify, o qual requer O(lg n) Tempo de execução de Heap-Insert é O(lg n). O caminho traçado da nova folha para a raiz têm compriemento da ordem de O(lg n).

Exemplos