Merge sort

Origem: Wikipédia, a enciclopédia livre.
Ir para: navegação, pesquisa
Merge sort

algoritmo mergesort
classe Algoritmo de ordenação
estrutura de dados Array, Listas ligadas
complexidade pior caso
complexidade caso médio
complexidade melhor caso típico,

variante natural

complexidade de espaços pior caso
Algoritmos

O merge sort, ou ordenação por mistura, é um exemplo de algoritmo de ordenação por comparação do tipo dividir-para-conquistar.

Sua ideia básica consiste em Dividir (o problema em vários sub-problemas e resolver esses sub-problemas através da recursividade) e Conquistar (após todos os sub-problemas terem sido resolvidos ocorre a conquista que é a união das resoluções dos sub-problemas). Como o algoritmo Merge Sort usa a recursividade, há um alto consumo de memória e tempo de execução, tornando esta técnica não muito eficiente em alguns problemas.

Características[editar | editar código-fonte]

Algoritmo[editar | editar código-fonte]

Os três passos úteis dos algoritmos de divisão e conquista, ou divide and conquer, que se aplicam ao merge sort são:

  1. Dividir: Calcula o ponto médio do sub-arranjo, o que demora um tempo constante ;
  2. Conquistar: Recursivamente resolve dois sub-problemas, cada um de tamanho n/2, o que contribui com para o tempo de execução;
  3. Combinar: Unir os sub-arranjos em um único conjunto ordenado, que leva o tempo .

Equação de recorrência[editar | editar código-fonte]

Árvore de recursão

Complexidade[editar | editar código-fonte]

  • Complexidade de tempo: .
  • Complexidade de espaço: .

Demonstração da complexidade de tempo[editar | editar código-fonte]

Para que teremos que fazer com que

Então:

Comparação com outros algoritmos de ordenação por comparação[editar | editar código-fonte]

Em comparação com outros algoritmos de divisão e conquista como o Quick sort o Merge apresentam a mesma complexidade, mas em comparação com os algoritmos mais básicos de ordenação por comparação e troca (bubble, insertion e selection sort), o Merge é mais rápido e eficiente, quando é utilizado uma grande quantidade de dados, para entradas pequenas os algoritmos de ordenação por comparação mais básicos são pró-eficientes.

Abaixo uma tabela para comparação:

Algoritmo Tempo
Melhor Médio Pior
Merge sort O(n*log(n)) O(n*log(n)) O(n*log(n))
Quick sort O(n*log(n)) O(n*log(n)) O(n2)
Bubble sort O(n) O(n2) O(n2)
Insertion sort O(n) O(n2) O(n2)
Selection sort O(n2) O(n2) O(n2)

Obs.: O Bubble sort apresenta melhor caso como O(n) porque o algoritmo pode ser modificado de forma que a lista já estando ordenando, basta apenas uma verificação básica que custa O(n), o Quick sort pode atingir um tempo de O(n2) em um caso específico quando o particionamento é desequilibrado.

Observações[editar | editar código-fonte]

Exemplo de execução do merge sort.
  • É possível implementar o merge sort utilizando somente um vetor auxiliar ao longo de toda a execução, tornando assim a complexidade de espaço adicional igual a .
  • É um algoritmo estável na maioria das implementações, em que elas podem ser iterativas ou recursivas.
  • É possível também implementar o algoritmo com espaço adicional .
  • Algoritmo Criado por Von Neumann em 1945.

Desvantagens[editar | editar código-fonte]

  • Utiliza funções recursivas;
  • Gasto extra de memória. O algoritmo cria uma cópia do vetor para cada nível da chamada recursiva, totalizando um uso adicional de memória igual a (n log n).

Implementações do Mergesort[editar | editar código-fonte]

Pseudocódigo[editar | editar código-fonte]

MERGE-SORT(A, p, r)
    if p < r
        then q = ((p + r) / 2)
            Merge-Sort(A, p, q)
            Merge-Sort(A, q + 1, r)
            Merge(A, p, q, r)

Merge(A, p, q, r)
    n1 = q - p + 1
    n2 = r - q
    sejam L[1 ... n1 + 1] e R[1 ... n2 + 1]
    for i = 1 to n1
        L[i] = A[p + i - 1]
    for j = 1 to n2
        R[j] = A[q + j]

    i = 1
    j = 1

    for k = p to r
        if L[i] <= R[j]
            then A[k] = L[i]
                i = i + 1
            else A[k] = R[j]
                j = j + 1

Código em C[editar | editar código-fonte]

 1 void merge(int vetor[], int comeco, int meio, int fim) {
 2     int com1 = comeco, com2 = meio+1, comAux = 0;
 3     int vetAux[fim-comeco+1];
 4 
 5     while(com1<=meio && com2<=fim){
 6         if(vetor[com1] <= vetor[com2]){
 7             vetAux[comAux] = vetor[com1];
 8             com1++;
 9         }else{
10             vetAux[comAux] = vetor[com2];
11             com2++;
12         }
13         comAux++;
14     }
15 
16     while(com1<=meio){  //Caso ainda haja elementos na primeira metade
17         vetAux[comAux] = vetor[com1];
18         comAux++;com1++;
19     }
20 
21     while(com2<=fim){   //Caso ainda haja elementos na segunda metade
22         vetAux[comAux] = vetor[com2];
23         comAux++;com2++;
24     }
25 
26     for(comAux=comeco;comAux<=fim;comAux++){    //Move os elementos de volta para o vetor original
27         vetor[comAux] = vetAux[comAux-comeco];
28     }
29 }
30 
31 void mergeSort(int vetor[], int comeco, int fim){
32     if (comeco < fim) {
33         int meio = (comeco+fim)/2;
34 
35         mergeSort(vetor, comeco, meio);
36         mergeSort(vetor, meio+1, fim);
37         merge(vetor, comeco, meio, fim);
38     }
39 }

Implementação em C++[editar | editar código-fonte]

void merge(int *, int, int, int);

void mergeSort(int *array, int inicio, int fim)
{
 if(inicio < fim)
 {
 int meio = (inicio + fim) / 2;

 mergeSort(array, inicio, meio);
 mergeSort(array, meio + 1, fim);
 merge(array, inicio, meio, fim);
 }
}

void merge(int *array, int inicio, int meio, int fim)
{
 int i, j, k, *auxiliar;

 i = inicio;
 j = meio + 1;
 k = fim;
 auxiliar = array;

 while(i <= meio && j <= fim)
 {
 if(auxiliar[i] < auxiliar[j])
 {
 array[k] = auxiliar[i];
 i++;
 }
 else
 {
 array[k] = auxiliar[j];
 j++;
 }
 k++;
 }

 while(i <= meio)
 {
 array[k] = auxiliar[i];
 i++;
 k++;
 }

 while(j <= fim)
 {
 array[k] = auxiliar[j];
 j++;
 k++;
 }
}

Código em Java[editar | editar código-fonte]

public class WikiMerge<T extends Comparable<T>>{
 /**
* Método que recebe um array de inteiros e dois inteiros referentes ao início e ao fim
* da ordenação desse array, o que nos garante o poder de escolher uma faixa do array
* para ser ordenado.
*
* @param array
* @param indiceInicio
* @param indiceFim
* /
 public void ordena(T[] array, int indiceInicio, int indiceFim){

 // Condicional que verifica a validade dos parâmetros passados.
 if (array != null && indiceInicio < indiceFim && indiceInicio >= 0 &&
 indiceFim < array.length && array.length != 0) {
 int meio = ((indiceFim + indiceInicio) / 2);

 ordena(array, indiceInicio, meio);
 ordena(array, meio + 1, indiceFim);

 merge(array, indiceInicio, meio, indiceFim);
 }

 }

 /**
* O merge consiste na junção de duas listas  ordenadas.
* Usa um array auxiliar.
*
* @param array
* @param indiceInicio
* @param meio
* @param indiceFim
* /
 public void merge(T[] array, int indiceInicio, int meio, int indiceFim) {

 T[] auxiliar =(T[]) new Comparable[array.length];
 //Copiando o trecho da lista que vai ser ordenada
 for (int i = indiceInicio; i <= indiceFim; i++) {
 auxiliar[i] = array[i];
 }

 //Índices auxiliares
 int i = indiceInicio;
 int j = meio + 1;
 int k = indiceInicio;

 //Junção das listas ordenadas
 while (i <= meio && j <= indiceFim) {
 if (auxiliar[i].compareTo(auxiliar[j]) < 0) {
 array[k] = auxiliar[i];
 i++;
 } else {
 array[k] = auxiliar[j];
 j++;
 }
 k++;
 }

 //Append de itens que não foram usados na Junção
 while (i <= meio) {
 array[k] = auxiliar[i];
 i++;
 k++;
 }

 //Append de itens que não foram usados na Junção
 while (j <= indiceFim) {
 array[k] = auxiliar[j];
 j++;
 k++;
 }
 }

}

Código em Python[editar | editar código-fonte]

def mergeSort(lista):

    if len(lista) > 1:

        meio = len(lista)/2

        listaDaEsquerda = lista[:meio]
        listaDaDireita = lista[meio:]

        mergeSort(listaDaEsquerda)
        mergeSort(listaDaDireita)

        i = 0
        j = 0
        k = 0

        while i < len(listaDaEsquerda) and j < len(listaDaDireita):

            if listaDaEsquerda[i] < listaDaDireita[j]:
                lista[k]=listaDaEsquerda[i]
                i += 1
            else:
                lista[k]=listaDaDireita[j]
                j += 1
            k += 1

        while i < len(listaDaEsquerda):

            lista[k]=listaDaEsquerda[i]
            i += 1
            k += 1

        while j < len(listaDaDireita):
            lista[k]=listaDaDireita[j]
            j += 1
            k += 1

Referências

  • Cormen, Thomas H.; Leiserson, Charles E.; Rivest, Ronald L.; Stein, Clifford (2009) [1990]. Algoritmos (3rd ed.). MIT Press and McGraw-Hill. ISBN 978-85-352-36-6

Ver também[editar | editar código-fonte]

Ligações externas[editar | editar código-fonte]