David menotti algoritmos e estruturas de dados i decom ufop
This presentation is the property of its rightful owner.
Sponsored Links
1 / 14

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


  • 52 Views
  • Uploaded on
  • Presentation posted in: General

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.

Download Presentation

David Menotti Algoritmos e Estruturas de Dados I DECOM – UFOP

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 0599 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 0599 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++];

}

}


Exemplo de mergesort2

Exemplo de MergeSort


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


  • Login