david menotti algoritmos e estruturas de dados i decom ufop
Download
Skip this Video
Download Presentation
David Menotti Algoritmos e Estruturas de Dados I DECOM – UFOP

Loading in 2 Seconds...

play fullscreen
1 / 14

David Menotti Algoritmos e Estruturas de Dados I DECOM – UFOP - PowerPoint PPT Presentation


  • 91 Views
  • Uploaded on

MergeSort Intercalação. David Menotti Algoritmos e Estruturas de Dados I DECOM – UFOP. 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.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about ' David Menotti Algoritmos e Estruturas de Dados I DECOM – UFOP' - honorato-soto


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
david menotti algoritmos e estruturas de dados i decom ufop

MergeSortIntercalação

David Menotti

Algoritmos e Estruturas de Dados I

DECOM – UFOP

problema de ordena o
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

abordagem dividir para conquistar
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.
abordagem balanceamento
Abordagem Balanceamento
  • Métodos de ordenação de divisão por conquista
    • SelectSort
    • QuickSort (pior caso?)
  • Divisão do problema de forma balanceada MergeSort
exemplo de mergesort
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 )

exemplo de mergesort1
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

algoritmo mergesort
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;

}

}

implementa o de intercala
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++];

}

}

implementa o do mergesort
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.
implementa o do mergesort1
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.
complexidade do mergesort
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

complexidade do mergesort1
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)

mergesort
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
ad