Algoritmos de Ordenação

Aluno: Rafael Justino de Brito

Bubble Sort
É o mais simples, porém, menos eficiente. Nesse algoritmo, cada elemento da
posição i será comparado com o elemento da posição i+1. Caso o elemento na
posição i+1 for maior que o da posição i, eles trocam de lugar e assim por
diante até o final do vetor.
Exemplo em C:
#include <stdio.h>int main(void){
int vetor[10] = {10,9,8,7,6,5,4,3,2,1};
int tamanho = 10;
int aux;
for(int i=tamanho-1; i >= 1; i--)
{
for( int j=0; j < i ; j++)
{
if(vetor[j]>vetor[j+1])
{
aux = vetor[j];
vetor[j] = vetor[j+1];
vetor[j+1] = aux;
}
}
}

for( int r = 0; r < 10; ++r)

{
printf("%d\n",vetor[r]);
}
}

Selection Sort
No início do algoritmo, é escolhido um número a partia do primeiro. Este
número escolhido é comparado com os outros números a partir da sua direita.
Quando encontrado um número menor que ele, o número escolhido ocupa a
posição do menor número encontrado. Este número encontrado será o próximo
número escolhido. Caso não for encontrado nenhum número menor que ele,
ele é colocado na posição do primeiro número escolhido e o próximo número á
sua direita vai ser o escolhido para fazer as comparações.
Exemplo em C:
void selection_sort(int num[], int tam)
{
int i, j, min, aux;
for (i = 0; i < (tam-1); i++)
{
min = i;
for (j = (i+1); j < tam; j++) {
if(num[j] < num[min])
 min = j;
}
if (i != min) {
aux = num[i];
num[i] = num[min];
num[min] = aux;
}
}
}

Insertion Sort
Neste algoritmo simples e eficiente quando aplicado em listas pequenas, a lista
é percorrida da esquerda para a direita e á medida que avança vai deixando os
elementos à sua esquerda ordenados.
Exemplo em C:
int *InsertionSort(int original[], int length){
int i, j, atual;
for (i = 1; i < length; i++)
{
atual = original[i];
j = i - 1;
while ((j >= 0) && (atual < original[j]))
{
original[j + 1] = original[j];
j = j - 1;
}
original[j + 1] = atual;
}
return (int*)original;
}

Qual o melhor?
O menos eficiente deles é o Bubble Sort pois é o que gasta mais tempo e faz o
maior número de movimentações dos elementos. O mais eficiente deles é o
Insertion, pois gasta bem menos tempo e faz menos comparações do que os
outros algoritmos em listas ordenadas de forma crescente. Ele perde para o
Selection em listas ordenadas de forma crescente e ganha do Selection, por
uma diferença pequena, em listas desordenadas.