David Menotti Algoritmos e Estruturas de Dados I DECOM – UFOP

1. MergeSortIntercalação David Menotti Algoritmos e Estruturas de Dados I DECOM – UFOP

2. Problema de Ordenação • Dado um arranjo com n números naturais, ordenar estes números em ordem crescente. Entrada: 95 48 70 86 21 37 Saída: 21 37 48 70 86 95

3. Abordagem Dividir-para-Conquistar • Método em Computação que consiste em • Dividir a entrada em conjuntos menores • Resolver cada instância menor de maneira recursiva • Reunir as soluções parciais para compor a solução do problema original.

4. Abordagem Balanceamento • Métodos de ordenação de divisão por conquista • SelectSort • QuickSort (pior caso?) • Divisão do problema de forma balanceada MergeSort

5. Exemplo de MergeSort Entrada: 47 26 33 05 99 38 64 15 • Divide: 47 26 33 0599 38 64 15 • Resolve Recursivamente: • Primeira metade 47 26 33 05 (Divide, Resolve recursivamente, Intercala Obtendo 05 26 33 47 ) • Segunda metade 99 38 64 15 (Divide, Resolve recursivamente, Intercala Obtendo 15 38 64 99 )

6. Exemplo de MergeSort Entrada: 47 26 33 05 99 38 64 15 • Resolve Recursivamente: • (Retorna 05 26 33 47 ) • (Retorna 15 38 64 99 ) • Intercala as soluções parciais: 05 15 26 33 38 47 64 99

7. Algoritmo MergeSort void MergeSort(Item* A,int ini,int fim) { int meio; if (fim == ini) return; else { meio = ( ini + fim ) / 2; MergeSort(A, ini, meio ); MergeSort(A, meio+1, fim); Intercala(A, ini, meio, fim ); return; } }

8. Implementação de Intercala IntercalaAB(Item* c,Item* a,int N,Item* b,int M) { int i, j, k; for (i = 0, j = 0, k = 0; k < N+M; k++) { if ( i == N ) { c[k] = b[j++]; continue; } if ( j == M ) { c[k] = a[i++]; continue; } if ( a[i] < b[j] ) c[k] = a[i++]; else c[k] = b[j++]; } }

9. Exemplo de MergeSort

10. Implementação do MergeSort • O procedimento Intercala requer o uso de um segundo arranjo, B, para receber os dados ordenados. • Note que no retorno de Mergesort com um arranjo de tamanho 1, a resposta encontra-se no arranjo A (o arranjo original de entrada). • No próximo nível (arranjo de comprimento 2) o resultado da intercalação estará no arranjo B. • Podemos administrar este problema de duas maneiras.

11. Implementação do MergeSort • Podemos administrar este problema de duas maneiras: • Copiando a porção do arranjo referente ao resultado de volta para o arranjo A, ou • Utilizando uma chave para indicar a “direção” dos movimentos de Intercala.

12. Complexidade do MergeSort TMergeSt(n) = 2 TMergesort(n/2) + cte n + cte Desenvolvendo TMS (n) = 2 TMS(n/2) + c n + c = 2 [ 2 TMS(n/4) + c n/2 + c ] + c n + c = 4 TMS(n/4) + 2c n + 3c = 4 [ 2 TMS(n/8) + c n/4 + c ] + 2c n + 3c = 8 TMS(n/8) + 3c n + 7c = ... TMS (n)= 2i TMS(n/2i) + i c n + (2i-1) c

13. Complexidade do MergeSort • Temos que TMS(n) = 2iTMS(n/2i) + i c n + (2i-1) c. • Tem-se que TMS(1) = 1 e (n/2i) = 1  (i = log2n). TMS(n) = 2log2n cte + (log2n) c n + (2log2n - 1) c = n cte + c n log2n + c (n-1) = c n log2n + (cte+c) n - c TMS(n) = O(n log2n)

14. MergeSort • Vantagens • Como HeapSort, MergeSort é O(n log n) • Indicado para aplicações que exigem restrição de tempo (executa sempre em um determinado tempo para um dado n) • Passível de ser transformado em estável • Implementação de intercala • Fácil Implementação • Desvantagens • Utiliza memória auxiliar – O(n) • Na prática mais lento que HeapSort