Merge sort

O Merge Sort é um algoritmo de ordenação baseado na técnica divisão-conquista, que funciona

dividindo um array em subarrays menores, ordenando cada subarray e, em seguida, mesclando
os subarrays ordenados para formar o array final ordenado.
1. Divisão: O array é dividido continuamente pela metade até que não possa mais ser dividido (ou
seja, o array tem apenas um elemento, que já está ordenado).
2. Ordenação: Os subarrays são ordenados individualmente. Um subarray com apenas um
elemento é considerado ordenado.
3. Mesclagem: Os subarrays ordenados são mesclados para formar um único array ordenado. Esse
processo é repetido até que o array inteiro esteja ordenado.
O Merge sort foi originalmente proposto por John von Neumann no final da década de 1940,
embora seu nome tenha sido popularizado por Jon Bentley em 1986.
Vantagens:
1- Eficiência: tanto para o melhor, médio e pior caso, a sua complexidade é n∗logn. Assim,
independente da disposição dos dados em um array, a ordenação será eficiente.
2- Estabilidade: O Merge Sort é um algoritmo estável, o que significa que ele mantém a
ordem relativa de elementos com chaves iguais. Isso é importante em casos em que a
ordem original dos dados deve ser preservada.
3- Implementação Simples: em termos de implementação, o Merge Sort é relativamente
simples e intuitivo de entender.
Desvantagens:
1- Uso de Memória Adicional: Uma das principais desvantagens do Merge Sort é que ele
requer espaço adicional na memória para armazenar as sublistas durante o processo de
mesclagem.
2- Complexidade Espacial: O Merge Sort tem uma complexidade espacial de O(n), o que
significa que ele pode consumir mais memória do que outros algoritmos de ordenação,
como o Quick Sort.
3- Desempenho Pior em Conjuntos de Dados Pequenos: para conjuntos de dados muito
pequenos, o Merge Sort pode ser menos eficiente do que algoritmos de ordenação mais
simples, devido ao seu overhead de divisão e mesclagem.
4- Não é In-place: O Merge Sort não é um algoritmo in-place, o que significa que ele não
pode classificar os elementos no local, exigindo espaço de memória adicional para
armazenar as sublistas durante a execução.

Representação visual do algoritmo.

 Implementação do algoritmo na linguagem c:

void mergeSort(int∗ vetor, int inicio, int fim){

if (inicio < fim) {

int meio = (inicio+fim)/2; //achar o meio do vector

mergeSort(vetor, inicio, meio); //vector à esquerda

mergeSort(vetor, meio+1, fim); //vector à direita

merge(vetor, inicio, meio, fim); //função de comparação, ordenação e junção

1 void merge(int vetor[], int inicio, int meio, int fim) {

2 int com1 = inicio, com2 = meio+1,− comAux = 0, vetAux[fim- inicio+1];

3 while(com1<=meio&& com2<=fim){
4 if(vetor[com1] <= vetor[com2]){
5 vetAux[comAux] = vetor[com1];
6 com1++;
7 }else{
8 vetAux[comAux] = vetor[com2];
9 com2++; }
10 comAux++; }
11 while(com1<=meio){ //Caso ainda haja elementos na primeira metade
12 vetAux[comAux] = vetor[com1];
13 comAux++;com1++; }
14 while(com2<=fim){ //Caso ainda haja elementos na segunda metade
15 vetAux[comAux] = vetor[com2];
16 comAux++;com2++; }
17 for(comAux=inicio;comAux<=fim;comAux++) //Move os elementos de volta
para o vetor original
18 vetor[comAux]
− = vetAux[comAux - inicio]; }