David menotti algoritmos e estruturas de dados i decom ufop
Download
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