Bubble Sort
No bubble sort é analisado de duas em duas posições de um vetor, ordenando conforme seja determinada a lógica, crescente ou decrescente;
A ideia é percorrer o vetor diversas vezes, a cada passagem fazendo flutuar para o topo o maior elemento da sequência.
Vantagem
A principal vantagem desse algoritmo é que sua implementação é fácil e conhecida.
Estável
Desvantagem
É um método simples, porém lento.
Não apresenta bons resultados quando a lista contém muitos itens.
O fato de o arquivo já estar ordenado não ajuda a reduzir o número de comparações (o custo continua quadrático), porém o número de movimentações cai para zero.
void bubble (int vetor[],int tamanho){
int aux;
for (int i=0; i<=tamanho; i++){
for (int j=0;j<=tamanho;j++){
if (vetor[i]<vetor[j]){
aux=vetor[i];
vetor[i] = vetor [j];
vetor[j] = aux;
}}}
Heap Sort
É uma árvore binária com seguintes propriedades: ○ O valor de cada pai é maior ou menor que os valores armazenados em cada filho; ○ As “folhas” no último nível estão todas nas posições mais à esquerda, podendo haver a falta de um elemento.
Vantagens
● O Algoritmo heapsort apresenta o tempo médio constante e satisfatório (até nos piores cenários);
● Consumo de memória baixo (mesmo em comparação com outros algoritmos de ordenação);
Desvantagens
● Não recomendado para entrada com poucos elementos, por conta do heap ser muito complexo;
● Não é tão rápido quanto o quicksort ou outros métodos em algumas situações;
● O Heapsort não é estável.
void max_heapify(int *a, int i, int n)
{
int j, temp;
temp = a[i];
j = 2*i;
while (j <= n)
{
if (j < n && a[j+1] > a[j])
j = j+1;
if (temp > a[j])
break;
else if (temp <= a[j])
{
a[j/2] = a[j];
j = 2*j;
}
}
a[j/2] = temp;
return;
}
void heapsort(int *a, int n)
{
int i, temp;
for (i = n; i >= 2; i--)
{
temp = a[i];
a[i] = a[1];
a[1] = temp;
max_heapify(a, 1, i - 1);
}
}
void build_maxheap(int *a, int n)
{
int i;
for(i = n/2; i >= 1; i--)
{
max_heapify(a, i, n);
}
}
int main()
{
int n, i, x;
cout<<"Enter no of elements of arrayn";
cin>>n;
int a[20];
for (i = 1; i <= n; i++)
{
cout<<"Enter element"<<(i)<<endl;
cin>>a[i];
}
build_maxheap(a,n);
heapsort(a, n);
cout<<"nnSorted Arrayn";
for (i = 1; i <= n; i++)
{
cout<<a[i]<<endl;
}
return 0;
}
Merge Sort
Vantagens
● Útil para ordenação externa;
● Pior caso: O(n log n);
● Aplicações com restrição de tempo;
● Fácil implementação.
Desvantagens
● Utiliza memória auxiliar;
● Possui dependência de outro vetor de tamanho idêntico;
● Alto consumo de memória.
VAZIO mergeSort(VETOR array)
SE TAMANHO(vetor) > 1 ENTÃO
NUMERICO mid, i
mid ← TAMANHO(vetor) / 2)
VETOR esquerda[mid], direita[TAMANHO(vetor) - mid]
PARA i ← 0 ATÉ TAMANHO(esquerda)
esquerda[i] ← array[i]
FIM
PARA i ← 0 ATÉ TAMANHO(direita)
direita[i] ← array[i]
FIM
//Recursão para distribuição
mergeSort(esquerda)
mergeSort(direita)
intercala(array, esquerda, direita)
ELSE
ESCREVA “Vetor já ordenado.”
FIM
FIM
VAZIO intercala(VETOR array, VETOR esquerda, VETOR direita)
NUMÉRICO i1 ← 0, i2 ← 0, i
PARA i ← 0 ATÉ TAMANHO(array)
// Verifica qual dos 2 valores é menor e isnere no
vetor
SE( i1 < TAMANHO(esquerda) E i2 < TAMANHO(direita)) ENTÃO
SE(esquerda[i1] < direita[i2]) ENTÃO
array[i] ←esquerda[i1]
i1 ← i1 + 1
ELSE
array[i] ← direita[i2]
i2 ← i2 + 1
FIM
FIM
//Caso os tamanhos dos vetores sejam diferentes, faz
a verificação individual de cada vetor
SENÃO SE (i1 < TAMANHO(esquerda)) ENTÃO
array[i] ← esquerda[i1]
i1 ← i1 + 1
SENÃO
array[i] ← direita[i2]
i2 ← i2 + 1
FIM
FIM
FIM
Insertion Sort
Vantagens
Simplicidade
Bom desempenho em listas pequenas
Desvantagens
Não funciona bem com listas grandes
N² passos necessários para funcionar
void InsertSort (int vet[]){
int i,j,aux;
for (i = 1; i < 5; i++){
j = i;
while (j > 0 && vet[j-1] > vet[j]) {
aux = vet[j];
vet[j] = vet[j-1];
vet[j-1] = aux;
j--;
}
}
}
int main(int argc, char** argv) {
int vet[5];
cout<<"Entre com 5 valores: \n";
for (int i = 0; i < 5; i++){
cin>>vet[i];
}
cout<<"\n";
InsertSort(vet);
cout<<"O vetor Ordenado e: \n";
for (int i = 0; i < 5; i++){
cout<<vet[i]<<"\n";
}
Bubble Sort
Vantagens
A principal vantagem desse algoritmo é que sua implementação é fácil e conhecida.
Estável
Desvantagens
É um método simples , porém lento .
Não apresenta bons resultados quando a lista contém muitos itens.
O fato de o arquivo já estar ordenado não ajuda a reduzir o número de comparações (o custo continua quadrático), porém o número de movimentações cai para zero.
void cresc(int vetor[]){
int aux;
for(int a=0;a<10;a++){
for(int b=0;b<10;b++){
if(vetor[a]<vetor[b]){
aux=vetor[a];
vetor[a]=vetor[b];
vetor[b]= aux;
}}}
for(int a=0;a<10;a++){
cout<<vetor[a]<<" ";
}
}
int main(int argc, char *argv[]){
int vetor[10];
for(int a=0;a<10;a++){cout<<" digite o "<<a+1<<" num: ";cin>>vetor[a];
} cresc(vetor);
system("PAUSE");
return EXIT_SUCCESS;
}
ShellSort
Vantagens:
Shellsort é uma ótima opção para arquivos de tamanho moderado;
Sua implementação é simples e requer uma quantidade de código pequena.
Desvantagens:
O tempo de execução do algoritmo é sensível à ordem inicial do arquivo;
O método não é estável.
void shellSort(int *vet, int size) { //Vou assumir que o tamanho do vetor é 8 ( size = vet[7]) int i , j , value; int gap = 1; while(gap < size) { gap = 3*gap+1; //Aqui é definido o espaçamento entre a verificação
} //das variáveis através do gap
while ( gap > 1) { //Tendo nota que seu valor não pode ser maior que
gap /= 3; //o tamanho do vetor que será ordenado
for(i = gap; i < size; i++) { value = vet[i]; //Vai pegando o valor no vetor com o espaçamento (Se gap for 4, pegar o índex 4, na prox rodada do for, pega o índex 5 etc.)
j = i - gap; //Mesma coisa que em cima, só que vai passando os índex 0,1,2,3 para o J (A variável value pega os valores do índex 4,5,6,7)
while (j >= 0 && value < vet[j]) { // Faz a verificação, basicamente se a variável do índex 4 for menor que a do índex 0, vet [j + gap] = vet[j]; // eles trocam de posição (Aliás, só um valor é trocado por enquanto)
j -= gap; // Aqui ele vai saindo do while depois de fazer as verificações, deixando o J menor que 0
} vet [j + gap] = value; //Aqui o outro valor é trocado, aquele que estava armazenado em value, note que o J só armazenou posição, } // enquanto o value armazenou o valor que estava na posição
}
}
QuickSort
Vantagens
É extremamente eficiente para ordenar arquivos de dados.
Necessita de apenas uma pequena pilha como memoria auxiliar.
Funciona muito bem com listas grandes de itens.
Para dados bem bagunçados o quicksort é mais vantajoso por ser mais econômico.
Desvantagens
Sua implementação é delicada e difícil. Um pequeno engano pode levar a efeitos inesperados para algumas entradas de dados.
O método não é estável.
#include<stdio.h>
void Quick(int vetor[10], int inicio, int fim);
int main(){
int vetor[10] = {7, 9, 4, 3, 6, 1, 18, 2, 10, 5};
int i;
printf("Vetor desordenado:\n");
for(i = 0; i < 10; i++){
printf("%d ", vetor[i]);
}
printf("\n");
Quick(vetor, 0, 9);
printf("Vetor ordenado:\n");
for(i = 0; i < 10; i++){
printf("%d ", vetor[i]);
}
printf("\n");
}
void Quick(int vetor[10], int inicio, int fim){
int pivo, aux, i, j, meio;
i = inicio;
j = fim;
meio = (int) ((i + j) / 2);
pivo = vetor[meio];
do{
while (vetor[i] < pivo) i = i + 1;
while (vetor[j] > pivo) j = j - 1;
if(i <= j){
aux = vetor[i];
vetor[i] = vetor[j];
vetor[j] = aux;
i = i + 1;
j = j - 1;
}
}while(j > i);
if(inicio < j) Quick(vetor, inicio, j);
if(i < fim) Quick(vetor, i, fim);
}
Recommended
