Ordenação em Tempo Linear. Leitura: Cormen Capítulo 8

Transcrição

1 Ordenação em Tempo Linear Leitura: Cormen Capítulo 8

2 Revisão Insertion sort: Vantagens Fácil de implementar Rápido em entradas com menos de 50 elementos. Rápido em entradas aproximadamente ordenadas. Desvantagens Pior caso: O(n 2 ) Caso médio : O(n 2 ) INSERTION-SORT (A, n) for j 2 to n do key A[ j] i j 1 while i > 0 and A[i] > key do A[i+1] A[i] i i 1 A[i+1] = key

3 Merge sort: Revisão Aplica abordagem dividir e conquistar: Divide o vetor ao meio Recursivamente ordena os subvetores gerados. Tempo linear na etapa merge. Vantagem O(n lg n) worst case Desvantagem Demanda O(n) espaço de memória adicional para executar merge.

4 Revisão

5 Heap sort: Revisão Utiliza estrutura de dados heap. Árvore binária Max Heap: Chave dos pais > Chave dos filhos Vantagens Pior caso: O(n lg n) In-place algorithm: transforma entradas usando uma estrutura de dados com uma quantidade reduzida e constante de espaço para armazenagem. Desvantagem: Geralmente mais lento do que quick e merge sort

6 Revisão Heapsort(A) 1 Build-Max-Heap(A) 2 for i = A.length downto 2 3 exchange A[1] A[i] 4 A.heap-size = A.heap-size -1 5 Max-Heapify(A,1) 16 Max-Heapify(A,2)

7 Quick sort: Revisão Abordagem dividir e conquistar: Particiona o vetor original em dois subvetores que são recursivamente ordenados. Todos os elemento do primeiro subvetor são menores que todos os elementos do segundo subvetor. Não há necessidade de um passo merge. Vantagens: Caso médio: O(n lg n). Rápido na prática. Desvantagem: Pior caso: O(n 2 ). Pior caso para entradas ordenadas. Pode ser resolvido aplicando randomized quicksort.

8 Revisão Quicksort(A, p, r) 1. if (p < r) 2. q = Partition(A, p, r); 3. Quicksort(A, p, q); 4. Quicksort(A, q+1, r);

9 Revisão Todos os algoritmos descritos anteriormente utilizam comparações para determinar a ordem relativa entre as entradas. O(nlgn): melhor pior caso visto até agora entre os algoritmos. Podemos ter ordenação em termpo linear? Árvore de decisão nos ajudará a responder isso.

10 Árvore de Decisão Todos os algoritmos descritos anteriormente utilizam comparações para determinar a ordem relativa entre as entradas. Considere a sequência de entrada a 1, a 2,, a n Lado esquerdo da árvore: a i a j. Lado direito da árvore: a i a j.

11 a 1, a 2,a 3 = 9, 4,6 Árvore de Decisão Lado esquerdo da árvore: a i a j. Lado direito da árvore: a i a j.

12 a 1, a 2,a 3 = 9, 4,6 Árvore de Decisão Lado esquerdo da árvore: a i a j. Lado direito da árvore: a i a j.

13 a 1, a 2,a 3 = 9, 4,6 Árvore de Decisão Lado esquerdo da árvore: a i a j. Lado direito da árvore: a i a j.

14 a 1, a 2,a 3 = 9, 4,6 Árvore de Decisão Os nós folhas representam permutações π(1), π(2),, π(n) que indicam a ordem a π(1) a π(2). a π(n).

15 Árvore de Decisão Uma árvore de decisão pode modelar a execução de qualquer algoritmo de comparação. Há uma árvore de decisão para cada entrada de tamanho n. Apresenta o algoritmo dividindo sempre que compara dois elementos. O tempo de execução do algoritmo é dado pelo tamanho do caminho. O pior caso é dado pela altura da árvore.

16 Limitante inferior para ordenação com Árvore de decisão Teorema: Qualquer árvore de decisão que pode ordenar n elementos precisa ter altura Ω(nlgn). Prova: A árvore precisa ter pelo menos n! folhas, desde que há n! possíveis permutações. Na altura h, a árvore binária possui no máximo 2 h folhas. Logo, n! 2 h. (lg é monotonicamente crescente) (Stirling s formula) L5.9

17 Limitante inferior para ordenação com Árvore de decisão Corolário: Merge and Heap sort são algorimtos de ordenação por comparação assintoticamente ótimos. L5.9

18 Ordenação por contagem Counting sort Não há comparações entre elementos. Assume que cada uma das n entradas é um inteiro entre 0 k para algum inteiro k. Entrada: A[1..n], onde A[j] {1, 2, 3,, k} Saída: B[1..n], ordenado C[1..k] é utilizado para armazenamento auxiliar.

19 Counting Sort Counting-Sort(A, B, k) 1 for i=0 to k 2 C[i]= 0; 3 for j=1 to A.length 4 C[A[j]] = C[A[j]] +1; 5 for i=1 to k 6 C[i] = C[i] + C[i-1]; 7 for j=a.length downto 1 8 B[C[A[j]]] = A[j]; 9 C[A[j]] = C[A[j]]-1;

20 Counting Sort Counting-Sort(A, B, k) 1 for i=0 to k 2 C[i]= 0; (k) 3 for j=1 to A.length 4 C[A[j]] = C[A[j]] +1; 5 for i=1 to k 6 C[i] = C[i] + C[i-1]; 7 for j=a.length downto 1 8 B[C[A[j]]] = A[j]; 9 C[A[j]] = C[A[j]]-1; (n) (k) (n) = (n+k)

21 Loop 1

22 Loop 2 for j=1 to n do C[A[j]] =C[A[j]] + 1

23 Loop 2 for j=1 to n do C[A[j]] =C[A[j]] + 1

24 Loop 2 for j=1 to n do C[A[j]] =C[A[j]] + 1

25 Loop 2 for j=1 to n do C[A[j]] =C[A[j]] + 1

26 Loop 2 for j=1 to n do C[A[j]] =C[A[j]] + 1

27 Loop 3 for i=2 to k do C[i] =C[i] + C[i 1]

28 Loop 3

29 Loop 3

30 Loop 4 for j=n downto 1 do B[C[A[j]]] =A[j] C[A[j]] =C[A[j]] 1

31 Loop 4 for j=n downto 1 do B[C[A[j]]] =A[j] C[A[j]] =C[A[j]] 1

32 Loop 4 for j=n downto 1 do B[C[A[j]]] =A[j] C[A[j]] =C[A[j]] 1

33 Loop 4 for j=n downto 1 do B[C[A[j]]] =A[j] C[A[j]] =C[A[j]] 1

34 Loop 4 for j=n downto 1 do B[C[A[j]]] =A[j] C[A[j]] =C[A[j]] 1

35 Counting Sort Counting sort deveria ser utilizado sempre, certo? Dependência em relação aos k elementos Exemplo: Ordendar inteiros codificados em 32 bits k= 2 32

36 Ordenação estável Stable sorting Algoritmos de ordenação estável preservam a ordem entre elementos iguais. Counting sort é estável A B

37 Radix sort As informações do censo de 1880 nos EUA levaram quase 10 anos para serem processadas. Herman Hollerith ( ), professor no MIT desde 1882, prototipou a tecnologia de cartões perfurados. Suas máquinas, incluindo um "classificador de cartões", permitiram que o censo de 1890 fosse processado em 6 semanas. Ele fundou a Tabulating Machine Company em 1911, que se fundiu com outras empresas em 1924 para formar International Business Machines (IBM).

38 Radix sort Ordenação dígito a dígito. Idéia original de Hollerith: classificar pelo dígito mais significativo. Boa ideia: classificar começando pelo dígito menos significativo utilizando uma ordenação estável auxiliar.

39 Radix sort RADIX_SORT(A,d) 1 for i = 1 to d 2 use a stable sort to sort array A on digit i

40 Radix sort Lemma 1 Dado n d-dígitos números, onde cada digito pode assumir até k valores possíveis, RADIX-SORT ordena corretamente esses números em (d(n + k)), se ordenação estável utilizada leva (n + k).

41 Radix sort Lemma 1 Dado n d-dígitos números, onde cada digito pode assumir até k valores possíveis, RADIX-SORT ordena corretamente esses números em (d(n + k)), se ordenação estável utilizada leva (n + k). Prova corretude: Indução na posição dos dígitos Assuma que os números estão ordenados pelos t-1 dígitos menos significativos Ordenar no dígito t : Dois números que diferem no dígito t são corretamente ordenados

42 Radix sort Lemma 1 Dado n d-dígitos números, onde cada digito pode assumir até k valores possíveis, RADIX-SORT ordena corretamente esses números em (d(n + k)), se ordenação estável utilizada leva (n + k). Prova corretude: Indução na posição dos dígitos Assuma que os números estão ordenados pelos t-1 dígitos menos significativos Ordenar no dígito t : Dois números que diferem no dígito t são corretamente ordenados Dois números iguais no dígito t são colodados na mesma ordem da entrada correta ordem.

43 Radix sort Lemma 1 Dado n d-dígitos números, onde cada digito pode assumir até k valores possíveis, RADIX-SORT ordena corretamente esses números em (d(n + k)), se ordenação estável utilizada leva (n + k). Prova tempo de execução: Assuma que estamos usando counting sort como ordenação estável auxiliar. Teremos: (n+k) por dígito 0,1,2,k. d dígitos (d(n+k)) Se k=n (dn)) Obs: Não é um in-place algoritmo, pois in-place possui apenas um número constante de elementos do vetor de entradas que são sempre armazenados fora do vetor.

44 Lemma 2 Radix sort Dado n b-dígitos números e qualquer inteiro positivo r b, RADIX-SORT ordena corretamente esses números em ((b/r)(n+2 r )), se a ordenação estável utilizada leva (n + k) para entradas variando de 0 até k. Prova: Escolha d = b/r. dígitos com r bits. Cada dígito representa um inteiro no interval 0 até 2 r -1 Cada execução do counting sort levará (n+k)= (n+2 r ) Há d dígitos a serem ordenados, logo (d(n+2 r ))= ((b/r)(n+2 r )).

45 Radix sort Exemplo: Palavra com 32-bits Para r = 8 b/r = 4 execuções do counting sort numa codificação com 2 8 dígitos; our r = 16 b/r = 2 execuções na codificação 2 16 dígitos.

46 Analysis of radix sort Critério para escolha do valor de r Desejamos escolher um valor de r b que minimize ((b/r)(n+2 r )) Seja r lg n, teremos: ((b/r)(n+2 r )) = ((b/lg n)(n+n)) = (bn/lg n) Para números entre 0 até n d 1, teremos: b =d lg n (dn) Exemplo: Para ordenar na codificação 2 16, palavras com 32-bits: n=2 16, b = 32, r = lg (2 16 )=16 bits, d = 32/16 = 2 execuções

47 Bin Sort Bin ou bucket sort, assim como counting sort, assume algo a respeito da entrada. Counting sort: assume que as entradas são inteiras em um pequeno intervalo. Bin sort: assume que a entrada é gerada aleatoriamente de forma uniforme e independente no intervalo [0,1).

48 Bin Sort Cria n listas ligadas para dividir o intervalo [0,1) em subintervalos de tamanho 1/n Adiciona cada elemento da entrada à lista apropriada e ordena cada lista com insertion sort.

49 Bin-Sort(A) Bin Sort 1 Seja B[0..n-1] um novo vetor 2 n = A.length 3 for i=0 to n-1 4 Faça B[i] uma lista vazia 5 for i = 1 to n 6 Insira A[i] na lista B[ na[i] ] 7 for i= 0 to n-1 8 Ordena B[i] com insertion sort9 9 Concatena listas B[0],B[1],,B[n-1] Análise Bin Sort: (n)